@types/atom

constructor

constructor(options: NodeProcessOptions);

• Runs the given Node script by spawning a new child process.

constructor

constructor(options: ProcessOptions);

property process

readonly process?: any;

method kill

kill: () => void;

• Terminate the process.

method onWillThrowError

onWillThrowError: (
    callback: (errorObject: HandleableErrorEvent) => void
) => Disposable;

• Will call your callback when an error will be raised by the process. Usually this is due to the command not being available or not on the PATH. You can call handle() on the object passed to your callback to indicate that you have handled this error.

method start

start: () => void;

• Runs the process.

constructor

constructor(...disposables: DisposableLike[]);

• Construct an instance, optionally with one or more disposables.

method add

add: (...disposables: DisposableLike[]) => void;

• Add disposables to be disposed when the composite is disposed. If this object has already been disposed, this method has no effect.

method clear

clear: () => void;

• Clear all disposables. They will not be disposed by the next call to dispose.

method delete

delete: (disposable: DisposableLike) => void;

• Alias to CompositeDisposable::remove.

method dispose

dispose: () => void;

• Dispose all disposables added to this composite disposable. If this object has already been disposed, this method has no effect.

method remove

remove: (disposable: DisposableLike) => void;

• Remove a previously added disposable.

constructor

constructor(directoryPath: string, symlink?: boolean);

• Configures a new Directory instance, no files are accessed.

method contains

contains: (pathToCheck: string) => boolean;

• Determines if the given path (real or symbolic) is inside this directory. This method does not actually check if the path exists, it just checks if the path is under this directory.

method create

create: (mode?: number) => Promise<boolean>;

• Creates the directory on disk that corresponds to ::getPath() if no such directory already exists.

method exists

exists: () => Promise<boolean>;

• Returns a promise that resolves to a boolean, true if the directory exists, false otherwise.

method existsSync

existsSync: () => boolean;

• Returns a boolean, true if the directory exists, false otherwise.

method getBaseName

getBaseName: () => string;

• Returns the string basename of the directory.

method getEntries

getEntries: (
    callback: (error: Error | null, entries: Array<File | Directory>) => void
) => void;

• Reads file entries in this directory from disk asynchronously.

method getEntriesSync

getEntriesSync: () => Array<File | Directory>;

• Reads file entries in this directory from disk synchronously.

method getFile

getFile: (filename: string) => File;

• Traverse within this Directory to a child File. This method doesn't actually check to see if the File exists, it just creates the File object.

method getParent

getParent: () => Directory;

• Traverse to the parent directory.

method getPath

getPath: () => string;

• This may include unfollowed symlinks or relative directory entries. Or it may be fully resolved, it depends on what you give it.

method getRealPathSync

getRealPathSync: () => string;

• All relative directory entries are removed and symlinks are resolved to their final destination.

method getSubdirectory

getSubdirectory: (dirname: string) => Directory;

• Traverse within this a Directory to a child Directory. This method doesn't actually check to see if the Directory exists, it just creates the Directory object.

method isDirectory

isDirectory: () => this is Directory;

• Returns a boolean, always true.

method isFile

isFile: () => this is File;

• Returns a boolean, always false.

method isRoot

isRoot: () => boolean;

• Return a boolean, true if this Directory is the root directory of the filesystem, or false if it isn't.

method isSymbolicLink

isSymbolicLink: () => boolean;

• Returns a boolean indicating whether or not this is a symbolic link.

method onDidChange

onDidChange: (callback: () => void) => Disposable;

• Invoke the given callback when the directory's contents change.

method relativize

relativize: (fullPath: string) => string;

• Returns the relative string path to the given path from this directory.

constructor

constructor(disposableAction?: () => void);

• Construct a Disposable.

method disposalAction

disposalAction: () => void;

• A callback which will be called within dispose().

method dispose

dispose: () => void;

• Perform the disposal action, indicating that the resource associated with this disposable is no longer needed.

method isDisposable

static isDisposable: (object: object) => boolean;

• Ensure that Object correctly implements the Disposable contract.

constructor

constructor();

• Construct an emitter.

method clear

clear: () => void;

• Clear out any existing subscribers.

method dispose

dispose: () => boolean;

• Unsubscribe all handlers.

method emit

emit: {
    <T extends keyof OptionalEmissions>(
        eventName: T,
        value?: OptionalEmissions[T]
    ): void;
    <T extends keyof RequiredEmissions>(
        eventName: T,
        value: RequiredEmissions[T]
    ): void;
};

• Invoke the handlers registered via ::on for the given event name.

method on

on: {
    <T extends keyof OptionalEmissions>(
        eventName: T,
        handler: (value?: OptionalEmissions[T]) => void
    ): Disposable;
    <T extends keyof RequiredEmissions>(
        eventName: T,
        handler: (value: RequiredEmissions[T]) => void
    ): Disposable;
};

• Registers a handler to be invoked whenever the given event is emitted.

method once

once: {
    <T extends keyof OptionalEmissions>(
        eventName: T,
        handler: (value?: OptionalEmissions[T]) => void
    ): Disposable;
    <T extends keyof RequiredEmissions>(
        eventName: T,
        handler: (value: RequiredEmissions[T]) => void
    ): Disposable;
};

• Register the given handler function to be invoked the next time an event with the given name is emitted via ::emit.

method preempt

preempt: {
    <T extends keyof OptionalEmissions>(
        eventName: T,
        handler: (value?: OptionalEmissions[T]) => void
    ): Disposable;
    <T extends keyof RequiredEmissions>(
        eventName: T,
        handler: (value: RequiredEmissions[T]) => void
    ): Disposable;
};

• Register the given handler function to be invoked before all other handlers existing at the time of subscription whenever events by the given name are emitted via ::emit.

constructor

constructor(filePath: string, symlink?: boolean);

• Configures a new File instance, no files are accessed.

method create

create: () => Promise<boolean>;

• Creates the file on disk that corresponds to ::getPath() if no such file already exists.

method createReadStream

createReadStream: () => ReadStream;

• Returns a stream to read the content of the file.

method createWriteStream

createWriteStream: () => WriteStream;

• Returns a stream to write content to the file.

method exists

exists: () => Promise<boolean>;

• Returns a promise that resolves to a boolean, true if the file exists, false otherwise.

method existsSync

existsSync: () => boolean;

• Returns a boolean, true if the file exists, false otherwise.

method getBaseName

getBaseName: () => string;

• Return the string filename without any directory information.

method getDigest

getDigest: () => Promise<string>;

• Get the SHA-1 digest of this file.

method getDigestSync

getDigestSync: () => string;

• Get the SHA-1 digest of this file.

method getEncoding

getEncoding: () => string;

• Returns the string encoding name for this file (default: "utf8").

method getParent

getParent: () => Directory;

• Return the Directory that contains this file.

method getPath

getPath: () => string;

• Returns the string path for the file.

method getRealPath

getRealPath: () => Promise<string>;

• Returns a promise that resolves to the file's completely resolved string path.

method getRealPathSync

getRealPathSync: () => string;

• Returns this file's completely resolved string path.

method isDirectory

isDirectory: () => this is Directory;

• Returns a boolean, always false.

method isFile

isFile: () => this is File;

• Returns a boolean, always true.

method isSymbolicLink

isSymbolicLink: () => boolean;

• Returns a boolean indicating whether or not this is a symbolic link.

method onDidChange

onDidChange: (callback: () => void) => Disposable;

• Invoke the given callback when the file's contents change.

method onDidDelete

onDidDelete: (callback: () => void) => Disposable;

• Invoke the given callback when the file is deleted.

method onDidRename

onDidRename: (callback: () => void) => Disposable;

• Invoke the given callback when the file's path changes.

method onWillThrowWatchError

onWillThrowWatchError: (
    callback: (event: PathWatchErrorThrownEvent) => void
) => Disposable;

• Invoke the given callback when there is an error with the watch. When your callback has been invoked, the file will have unsubscribed from the file watches.

method read

read: (flushCache?: boolean) => Promise<string | null>;

• Reads the contents of the file.

method setEncoding

setEncoding: (encoding: string) => void;

• Sets the file's character set encoding name.

method write

write: (text: string) => Promise<undefined>;

• Overwrites the file with the given text.

method writeSync

writeSync: (text: string) => undefined;

• Overwrites the file with the given text.

constructor

constructor(
    path: string,
    options?: {
        refreshOnWindowFocus?: boolean | undefined;
        config?: Config | undefined;
        project?: Project | undefined;
    }
);

method checkoutHead

checkoutHead: (path: string) => boolean;

• Restore the contents of a path in the working directory and index to the version at HEAD.

method checkoutReference

checkoutReference: (reference: string, create: boolean) => boolean;

• Checks out a branch in your repository.

method destroy

destroy: () => void;

• Destroy this GitRepository object.

method getAheadBehindCount

getAheadBehindCount: (
    reference: string,
    path?: string
) => { ahead: number; behind: number };

• Returns the number of commits behind the current branch is from the its upstream remote branch. The default reference is the HEAD.

  Parameter reference

  The branch reference name.

  Parameter path

  The path in the repository to get this ifnromation for, only needed if the repository contains submodules. Returns the number of commits behind the current branch is from its upstream remote branch.

method getCachedPathStatus

getCachedPathStatus: (path: string) => number | null;

• Get the cached status for the given path.

method getCachedUpstreamAheadBehindCount

getCachedUpstreamAheadBehindCount: (path?: string) => {
    ahead: number;
    behind: number;
};

• Get the cached ahead/behind commit counts for the current branch's upstream branch.

method getConfigValue

getConfigValue: (key: string, path?: string) => string;

• Returns the git configuration value specified by the key.

method getDiffStats

getDiffStats: (path: string) => { added: number; deleted: number };

• Retrieves the number of lines added and removed to a path. This compares the working directory contents of the path to the HEAD version.

method getDirectoryStatus

getDirectoryStatus: (path: string) => number;

• Get the status of a directory in the repository's working directory.

method getLineDiffs

getLineDiffs: (
    path: string,
    text: string
) => Array<{
    oldStart: number;
    newStart: number;
    oldLines: number;
    newLines: number;
}>;

• Retrieves the line diffs comparing the HEAD version of the given path and the given text.

method getOriginURL

getOriginURL: (path?: string) => string;

• Returns the origin url of the repository.

method getPath

getPath: () => string;

• Returns the string path of the repository.

method getPathStatus

getPathStatus: (path: string) => number;

• Get the status of a single path in the repository.

method getReferences

getReferences: (path?: string) => {
    heads: string[];
    remotes: string[];
    tags: string[];
};

• Gets all the local and remote references.

method getReferenceTarget

getReferenceTarget: (reference: string, path?: string) => string;

• Returns the current string SHA for the given reference.

method getShortHead

getShortHead: (path?: string) => string;

• Retrieves a shortened version of the HEAD reference value.

method getType

getType: () => 'git';

• A string indicating the type of version control system used by this repository.

method getUpstreamBranch

getUpstreamBranch: (path?: string) => string | null;

• Returns the upstream branch for the current HEAD, or null if there is no upstream branch for the current HEAD.

method getWorkingDirectory

getWorkingDirectory: () => string;

• Returns the string working directory path of the repository.

method hasBranch

hasBranch: (branch: string) => boolean;

• Returns true if the given branch exists.

method isDestroyed

isDestroyed: () => boolean;

• Returns a boolean indicating if this repository has been destroyed.

method isPathIgnored

isPathIgnored: (path: string) => boolean;

• Is the given path ignored?

method isPathModified

isPathModified: (path: string) => boolean;

• Returns true if the given path is modified.

method isPathNew

isPathNew: (path: string) => boolean;

• Returns true if the given path is new.

method isProjectAtRoot

isProjectAtRoot: () => boolean;

• Returns true if at the root, false if in a subfolder of the repository.

method isStatusModified

isStatusModified: (status: number) => boolean;

• Returns true if the given status indicates modification.

method isStatusNew

isStatusNew: (status: number) => boolean;

• Returns true if the given status indicates a new path.

method isSubmodule

isSubmodule: (path: string) => boolean;

• Is the given path a submodule in the repository?

method onDidChangeStatus

onDidChangeStatus: (
    callback: (event: RepoStatusChangedEvent) => void
) => Disposable;

• Invoke the given callback when a specific file's status has changed. When a file is updated, reloaded, etc, and the status changes, this will be fired.

method onDidChangeStatuses

onDidChangeStatuses: (callback: () => void) => Disposable;

• Invoke the given callback when a multiple files' statuses have changed.

method onDidDestroy

onDidDestroy: (callback: () => void) => Disposable;

• Invoke the given callback when this GitRepository's destroy() method is invoked.

method open

static open: (
    path: string,
    options?: { refreshOnWindowFocus?: boolean | undefined }
) => GitRepository;

• Creates a new GitRepository instance.

method relativize

relativize: () => string;

• Makes a path relative to the repository's working directory.

constructor

constructor(
    type: 'info' | 'warning' | 'success',
    message: string,
    options?: NotificationOptions
);

constructor

constructor(
    type: 'error' | 'fatal',
    message: string,
    options?: ErrorNotificationOptions
);

method dismiss

dismiss: () => void;

• Dismisses the notification, removing it from the UI. Calling this programmatically will call all callbacks added via onDidDismiss.

method getMessage

getMessage: () => string;

• Returns the Notification's message.

method getType

getType: () => string;

• Returns the Notification's type.

method onDidDismiss

onDidDismiss: (callback: (notification: Notification) => void) => Disposable;

• Invoke the given callback when the notification is dismissed.

method onDidDisplay

onDidDisplay: (callback: (notification: Notification) => void) => Disposable;

• Invoke the given callback when the notification is displayed.

constructor

constructor(row?: number, column?: number);