@types/tmp

Variables

• tmpdir

Functions

• dir()
• dirSync()
• file()
• fileSync()
• setGracefulCleanup()
• tmpName()
• tmpNameSync()

Interfaces

• DirOptions

  • keep
  • mode
  • unsafeCleanup
• DirResult

  • name
  • removeCallback
• FileOptions

  • detachDescriptor
  • discardDescriptor
  • keep
  • mode
• FileOptionsDiscardFd

  • discardDescriptor
• FileResult

  • fd
  • name
  • removeCallback
• TmpNameOptions

  • dir
  • name
  • postfix
  • prefix
  • template
  • tmpdir
  • tries

Type Aliases

• DirCallback
• FileCallback
• FileCallbackNoFd
• FileResultNoFd
• TmpNameCallback

variable tmpdir

const tmpdir: string;

function dir

dir: { (options: DirOptions, cb: DirCallback): void; (cb: DirCallback): void };

• Asynchronous directory creation.

  Simple temporary directory creation, it will be removed on process exit.

  If the directory still contains items on process exit, then it won't be removed.

  Example 1

  import * as tmp from 'tmp';

  tmp.dir((err, path, cleanupCallback) => { if (err) throw err;

  console.log('Dir: ', path);

  // Manual cleanup cleanupCallback(); });

function dirSync

dirSync: (options?: DirOptions) => DirResult;

• Synchronous directory creation.

  Simple synchronous temporary directory creation, it will be removed on process exit.

  If the directory still contains items on process exit, then it won't be removed.

  Example 1

  import * as tmp from 'tmp';

  const tmpobj = tmp.dirSync(); console.log('Dir: ', tmpobj.name); // Manual cleanup tmpobj.removeCallback();

function file

file: {
    (options: FileOptionsDiscardFd, cb: FileCallbackNoFd): void;
    (options: FileOptions, cb: FileCallback): void;
    (cb: FileCallback): void;
};

• Asynchronous file creation.

  Simple temporary file creation, the file will be closed and unlinked on process exit.

  Example 1

  import * as tmp from 'tmp';

  tmp.file((err, path, fd, cleanupCallback) => { if (err) throw err;

  console.log('File: ', path); console.log('Filedescriptor: ', fd);

  // If we don't need the file anymore we could manually call the cleanupCallback // But that is not necessary if we didn't pass the keep option because the library // will clean after itself. cleanupCallback(); });

function fileSync

fileSync: {
    (options: FileOptionsDiscardFd): FileResultNoFd;
    (options?: FileOptions): FileResult;
};

• Synchronous file creation.

  Simple synchronous temporary file creation, the file will be closed and unlinked on process exit.

  Example 1

  import * as tmp from 'tmp';

  const tmpobj = tmp.fileSync(); console.log('File: ', tmpobj.name); console.log('Filedescriptor: ', tmpobj.fd);

  // If we don't need the file anymore we could manually call the removeCallback // But that is not necessary if we didn't pass the keep option because the library // will clean after itself. tmpobj.removeCallback();

function setGracefulCleanup

setGracefulCleanup: () => void;

• Graceful cleanup.

  If graceful cleanup is set, tmp will remove all controlled temporary objects on process exit, otherwise the temporary objects will remain in place, waiting to be cleaned up on system restart or otherwise scheduled temporary object removal.

  Example 1

  import * as tmp from 'tmp';

  tmp.setGracefulCleanup();

function tmpName

tmpName: {
    (options: TmpNameOptions, cb: TmpNameCallback): void;
    (cb: TmpNameCallback): void;
};

• Asynchronous filename generation.

  Generates a unique filename in the specified directory.

  Example 1

  import * as tmp from 'tmp';

  tmp.tmpName((err, path) => { if (err) throw err;

  console.log('Created temporary filename: ', path); });

function tmpNameSync

tmpNameSync: (options?: TmpNameOptions) => string;

• Synchronous filename generation.

  Synchronously generates a unique filename in the specified directory.

  Example 1

  import * as tmp from 'tmp';

  const name = tmp.tmpNameSync(); console.log('Created temporary filename: ', name);

type DirCallback

type DirCallback = (
    err: Error | null,
    name: string,
    removeCallback: () => void
) => void;

type FileCallback

type FileCallback = (
    err: Error | null,
    name: string,
    fd: number,
    removeCallback: () => void
) => void;

type FileCallbackNoFd

type FileCallbackNoFd = (
    err: Error | null,
    name: string,
    fd: undefined,
    removeCallback: () => void
) => void;

type FileResultNoFd

type FileResultNoFd = Omit<FileResult, 'fd'>;

type TmpNameCallback

type TmpNameCallback = (err: Error | null, name: string) => void;