How to use the temp-file.TmpDir function in temp-file

if (checkOptions.signed) {
    packagerOptions = signed(packagerOptions)
  }
  if (checkOptions.signedWin) {
    configuration.cscLink = WIN_CSC_LINK
    configuration.cscKeyPassword = ""
  }
  else if ((configuration as Configuration).cscLink == null) {
    packagerOptions = deepAssign({}, packagerOptions, {config: {mac: {identity: null}}})
  }

  const projectDirCreated = checkOptions.projectDirCreated
  let projectDir = path.join(__dirname, "..", "..", "fixtures", fixtureName)
  // const isDoNotUseTempDir = platform === "darwin"
  const customTmpDir = process.env.TEST_APP_TMP_DIR
  const tmpDir = checkOptions.tmpDir || new TmpDir(`pack-tester: ${fixtureName}`)
  // non-macOS test uses the same dir as macOS test, but we cannot share node_modules (because tests executed in parallel)
  const dir = customTmpDir == null ? await tmpDir.createTempDir({prefix: "test-project"}) : path.resolve(customTmpDir)
  if (customTmpDir != null) {
    await emptyDir(dir)
    log.info({customTmpDir}, "custom temp dir used")
  }

  await copyDir(projectDir, dir, {
    filter: it => {
      const basename = path.basename(it)
      // if custom project dir specified, copy node_modules (i.e. do not ignore it)
      return (packagerOptions.projectDir != null || basename !== "node_modules") && (!basename.startsWith(".") || basename === ".babelrc")
    },
    isUseHardLink: USE_HARD_LINKS,
  })
  projectDir = dir

exports.default = async function (configuration) {
    // log.info(configuration, 'sign config');
    // Only process on one hash, we set hashes manually to control the order
    if (configuration.hash === 'sha1') {
        return;
    }
    const vm = new _vm.VmManager();
    const tempDirManager = new tempFile.TmpDir('packager');

    
    // signtool.exe
    // const windowsCodeSign = require("app-builder-lib/out/codeSign/windowsCodeSign");
    // const vendorPath = await windowsCodeSign.getSignVendorPath();
    // const signTool = path.join(vendorPath, "windows-10", process.arch, "signtool.exe");

    // https://github.com/vcsjones/AzureSignTool
    const signTool = "azuresigntool";
    
    // Appending each sig puts it after the top one, so the order here is a bit odd
    // For 4 signatures, sign in the following order: 1 4 3 2

    // 1
    let argsSha256 = computeAzureSignToolArgs(configuration, vm, false);
    log.info({hash: 'sha256', path: configuration.path, tool: signTool}, 'signing');

import { ElectronWebpackConfiguration } from "electron-webpack"
import { copy, emptyDir } from "fs-extra"
import MemoryFS from "memory-fs"
import * as path from "path"
import { TmpDir } from "temp-file"
import webpack, { Configuration, Stats } from "webpack"

export const tmpDir = new TmpDir()

export const rootDir = path.join(__dirname, "..", "..", "..")

export async function doTest(configurationFile: string, electronWebpackConfiguration?: ElectronWebpackConfiguration) {
  const projectDir = await getMutableProjectDir()
  const finalConfiguration = {projectDir, ...electronWebpackConfiguration}
  const configuration = await require(`electron-webpack/${configurationFile}`)({configuration: finalConfiguration, production: true})
  await testWebpack(configuration, projectDir)
}

export async function getMutableProjectDir(fixtureName = "simple") {
  const projectDir = process.env.TEST_APP_TMP_DIR || await tmpDir.getTempDir()
  await emptyDir(projectDir)
  await copy(path.join(rootDir, "test/fixtures", fixtureName), projectDir)
  return projectDir
}

async function getGradleClasspathDependencies(p: Project): Promise {
    const lp = p as LocalProject;
    const initScript = `allprojects {
    apply plugin: "java"
    task listCompilePath(dependsOn: configurations.compileClasspath) {
        doLast {
            println "classpath=\${configurations.testCompileClasspath.collect { File file -> file }.join('${path.delimiter}')}"
        }
    }
}`;
    const tempFile = await new TmpDir().getTempFile({prefix: "init", suffix: ".gradle"});
    await fs.writeFile(tempFile, initScript);
    const log = new StringCapturingProgressLog();
    await spawnLog(await determineGradleCommand(p), ["--init-script", tempFile, "listCompilePath"], {log, cwd: lp.baseDir});
    const result = /classpath=(.*)/.exec(log.log);
    if (result) {
        return result[1]
            .split(path.delimiter)
            .map(element => {
                return element.substr(element.lastIndexOf(path.sep) + 1);
            });
    } else {
        return [];
    }
}

async function getMavenClasspathDependencies(p: Project): Promise {
    const lp = p as LocalProject;
    const log = new StringCapturingProgressLog();
    const tempFile = await new TmpDir().getTempFile({prefix: "classpath", suffix: ".txt"});
    await spawnLog(await determineMavenCommand(p), ["dependency:build-classpath", `-Dmdep.outputFile=${tempFile}`], {log, cwd: lp.baseDir});
    const classpath = await fs.readFile(tempFile, "UTF-8");
    return classpath
        .split(path.delimiter)
        .map(element => {
            return element.substr(element.lastIndexOf(path.sep) + 1);
        });
}