@pulsar-edit/types 1.128.1

package/src/project.d.ts

@@ -0,0 +1,110 @@
+import {
+  ConfigValues,
+  Directory,
+  Disposable,
+  FilesystemChangeEvent,
+  GitRepository,
+  PathWatcher,
+  TextBuffer,
+} from "../index";
+
+/** Represents a project that's opened in Atom. */
+export interface Project {
+  // Event Subscription
+  /** Invoke the given callback when the project paths change. */
+  onDidChangePaths(callback: (projectPaths: string[]) => void): Disposable;
+
+  /** Invoke the given callback when a text buffer is added to the project. */
+  onDidAddBuffer(callback: (buffer: TextBuffer) => void): Disposable;
+
+  /**
+   *  Invoke the given callback with all current and future text buffers in
+   *  the project.
+   */
+  observeBuffers(callback: (buffer: TextBuffer) => void): Disposable;
+
+  /**
+   * Invoke a callback when a filesystem change occurs within any open project
+   * path.
+   */
+  onDidChangeFiles(callback: (events: FilesystemChangeEvent) => void): Disposable;
+
+  /**
+   * Invoke a callback whenever the project's configuration has been replaced.
+   */
+  onDidReplace(
+    callback: (projectSpec: ProjectSpecification | null | undefined) => void
+  ): Disposable;
+
+  // Accessing the Git Repository
+  /**
+   * Get an Array of GitRepositorys associated with the project's directories.
+   *
+   * This method will be removed in 2.0 because it does synchronous I/O.
+   */
+  getRepositories(): GitRepository[];
+
+  /**
+   * Invoke the given callback with all current and future repositories in the
+   * project.
+   */
+  observeRepositories(callback: (repository: GitRepository) => void): Disposable;
+
+  /** Invoke the given callback when a repository is added to the project. */
+  onDidAddRepository(callback: (repository: GitRepository) => void): Disposable;
+
+  /** Get the repository for a given directory asynchronously. */
+  repositoryForDirectory(directory: Directory): Promise<GitRepository | null>;
+
+  // Managing Paths
+  /**
+   * Get an Array of strings containing the paths of the project's directories.
+   */
+  getPaths(): string[];
+
+  /** Set the paths of the project's directories. */
+  setPaths(projectPaths: string[]): void;
+
+  /** Add a path to the project's list of root paths. */
+  addPath(projectPath: string): void;
+
+  /**
+   * Access a promise that resolves when the filesystem watcher associated with
+   * a project root directory is ready to begin receiving events.
+   */
+  getWatcherPromise(projectPath: string): Promise<PathWatcher>;
+
+  /** Remove a path from the project's list of root paths. */
+  removePath(projectPath: string): void;
+
+  /** Get an Array of {@link Directory}s associated with this project. */
+  getDirectories(): Directory[];
+
+  /**
+   * Undocumented: Get the {@link Directory} associated with a path within this
+   * project.
+   */
+  getDirectoryForProjectPath(projectPath: string): Directory;
+
+  /** Get the relative path from the project directory to the given path. */
+  relativize(fullPath: string): string;
+
+  /**
+   * Get the path to the project directory that contains the given path, and
+   * the relative path from that project directory to the given path.
+   */
+  relativizePath(fullPath: string): [string | null, string];
+
+  /**
+   * Determines whether the given path (real or symbolic) is inside the
+   * project's directory.
+   */
+  contains(pathToCheck: string): boolean;
+
+}
+
+export interface ProjectSpecification {
+  paths: string[];
+  originPath: string;
+  config?: ConfigValues | undefined;
+}

package/src/scope-descriptor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wraps an array of strings. The array describes a path from the root of the
+ * syntax tree to a token including all scope names for the entire path.
+ */
+export interface ScopeDescriptor {
+  /** Returns all scopes for this descriptor. */
+  getScopesArray(): readonly string[];
+}

package/src/selection.d.ts

@@ -0,0 +1,341 @@
+import {
+  Disposable,
+  PointCompatible,
+  Range,
+  RangeCompatible,
+  RangeLike,
+  ReadonlyEditOptions,
+  TextInsertionOptions,
+  TextEditor
+} from "../index";
+
+/** Represents a selection in the {@link TextEditor}. */
+export interface Selection {
+  // Event Subscription
+  /** Calls your callback when the selection was moved. */
+  onDidChangeRange(callback: (event: SelectionChangedEvent) => void): Disposable;
+
+  /** Calls your callback when the selection was destroyed. */
+  onDidDestroy(callback: () => void): Disposable;
+
+  // Managing the selection range
+  /** Returns the screen Range for the selection. */
+  getScreenRange(): Range;
+
+  /** Modifies the screen range for the selection. */
+  setScreenRange(
+    screenRange: RangeCompatible,
+    options?: {
+      preserveFolds?: boolean | undefined;
+      autoscroll?: boolean | undefined;
+    },
+  ): void;
+
+  /** Returns the buffer Range for the selection. */
+  getBufferRange(): Range;
+
+  /** Modifies the buffer Range for the selection. */
+  setBufferRange(
+    bufferRange: RangeCompatible,
+    options?: {
+      reversed?: boolean | undefined;
+      preserveFolds?: boolean | undefined;
+      autoscroll?: boolean | undefined;
+    },
+  ): void;
+
+  /** Returns the starting and ending buffer rows the selection is highlighting. */
+  getBufferRowRange(): [number, number];
+
+  // Info about the selection
+  /** Determines if the selection contains anything. */
+  isEmpty(): boolean;
+
+  /**
+   * Determines if the ending position of a marker is greater than the starting
+   * position. This can happen when, for example, you highlight text "up" in a
+   * {@link TextBuffer}.
+   */
+  isReversed(): boolean;
+
+  /** Returns whether the selection is a single line or not. */
+  isSingleScreenLine(): boolean;
+
+  /** Returns the text in the selection. */
+  getText(): string;
+
+  // NOTE: this calls into Range.intersectsWith(), which is one of the few
+  // functions that doesn't take a range-compatible range, despite what the API
+  // says.
+  /** Identifies if a selection intersects with a given buffer range. */
+  intersectsBufferRange(bufferRange: RangeLike): boolean;
+
+  /** Identifies if a selection intersects with another selection. */
+  intersectsWith(otherSelection: Selection): boolean;
+
+  // Modifying the selected range
+  /** Clears the selection, moving the marker to the head. */
+  clear(options?: { autoscroll?: boolean | undefined }): void;
+
+  /** Selects the text from the current cursor position to a given screen position. */
+  selectToScreenPosition(position: PointCompatible): void;
+
+  /** Selects the text from the current cursor position to a given buffer position. */
+  selectToBufferPosition(position: PointCompatible): void;
+
+  /** Selects the text one position right of the cursor. */
+  selectRight(columnCount?: number): void;
+
+  /** Selects the text one position left of the cursor. */
+  selectLeft(columnCount?: number): void;
+
+  /** Selects all the text one position above the cursor. */
+  selectUp(rowCount?: number): void;
+
+  /** Selects all the text one position below the cursor. */
+  selectDown(rowCount?: number): void;
+
+  /**
+   * Selects all the text from the current cursor position to the top of the
+   * buffer.
+   */
+  selectToTop(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the bottom of
+   * the buffer.
+   */
+  selectToBottom(): void;
+
+  /** Selects all the text in the buffer. */
+  selectAll(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the beginning of
+   * the line.
+   */
+  selectToBeginningOfLine(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the first character
+   * of the line.
+   */
+  selectToFirstCharacterOfLine(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the end of the
+   * screen line.
+   */
+  selectToEndOfLine(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the end of the
+   * buffer line.
+   */
+  selectToEndOfBufferLine(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the beginning
+   * of the word.
+   */
+  selectToBeginningOfWord(): void;
+
+  /** Selects all the text from the current cursor position to the end of the word. */
+  selectToEndOfWord(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the beginning of
+   * the next word.
+   */
+  selectToBeginningOfNextWord(): void;
+
+  /** Selects text to the previous word boundary. */
+  selectToPreviousWordBoundary(): void;
+
+  /** Selects text to the next word boundary. */
+  selectToNextWordBoundary(): void;
+
+  /** Selects text to the previous subword boundary. */
+  selectToPreviousSubwordBoundary(): void;
+
+  /** Selects text to the next subword boundary. */
+  selectToNextSubwordBoundary(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the beginning of
+   * the next paragraph.
+   */
+  selectToBeginningOfNextParagraph(): void;
+
+  /**
+   * Selects all the text from the current cursor position to the beginning of
+   * the previous paragraph.
+   */
+  selectToBeginningOfPreviousParagraph(): void;
+
+  /** Modifies the selection to encompass the current word. */
+  selectWord(): void;
+
+  /**
+   * Expands the newest selection to include the entire word on which the
+   * cursors rests.
+   */
+  expandOverWord(): void;
+
+  /** Selects an entire line in the buffer. */
+  selectLine(row: number): void;
+
+  /**
+   * Expands the newest selection to include the entire line on which the cursor
+   * currently rests.
+   * It also includes the newline character.
+   */
+  expandOverLine(): void;
+
+  // Modifying the selected text
+  /** Replaces text at the current selection. */
+  insertText(text: string, options?: TextInsertionOptions & ReadonlyEditOptions): void;
+
+  /**
+   * Removes the first character before the selection if the selection is empty
+   * otherwise it deletes the selection.
+   */
+  backspace(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes the selection or, if nothing is selected, then all characters from
+   * the start of the selection back to the previous word boundary.
+   */
+  deleteToPreviousWordBoundary(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes the selection or, if nothing is selected, then all characters from
+   * the start of the selection up to the next word boundary.
+   */
+  deleteToNextWordBoundary(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes from the start of the selection to the beginning of the current
+   * word if the selection is empty otherwise it deletes the selection.
+   */
+  deleteToBeginningOfWord(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes from the beginning of the line which the selection begins on all
+   * the way through to the end of the selection.
+   */
+  deleteToBeginningOfLine(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes the selection or the next character after the start of the selection
+   * if the selection is empty.
+   */
+  delete(options?: ReadonlyEditOptions): void;
+
+  /**
+   * If the selection is empty, removes all text from the cursor to the end of
+   * the line. If the cursor is already at the end of the line, it removes the
+   * following newline. If the selection isn't empty, only deletes the contents
+   * of the selection.
+   */
+  deleteToEndOfLine(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes the selection or all characters from the start of the selection to
+   * the end of the current word if nothing is selected.
+   */
+  deleteToEndOfWord(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes the selection or all characters from the start of the selection to
+   * the end of the current word if nothing is selected.
+   */
+  deleteToBeginningOfSubword(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes the selection or all characters from the start of the selection to
+   * the end of the current word if nothing is selected.
+   */
+  deleteToEndOfSubword(options?: ReadonlyEditOptions): void;
+
+  /** Removes only the selected text. */
+  deleteSelectedText(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Removes the line at the beginning of the selection if the selection is
+   * empty unless the selection spans multiple lines in which case all lines
+   * are removed.
+   */
+  deleteLine(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Joins the current line with the one below it. Lines will be separated by a
+   * single space. If there selection spans more than one line, all the lines
+   * are joined together.
+   */
+  joinLines(options?: ReadonlyEditOptions): void;
+
+  /** Removes one level of indent from the currently selected rows. */
+  outdentSelectedRows(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Sets the indentation level of all selected rows to values suggested by the
+   * relevant grammars.
+   */
+  autoIndentSelectedRows(options?: ReadonlyEditOptions): void;
+
+  /**
+   * Wraps the selected lines in comments if they aren't currently part of a
+   * comment. Removes the comment if they are currently wrapped in a comment.
+   */
+  toggleLineComments(options?: ReadonlyEditOptions): void;
+
+  /** Cuts the selection until the end of the screen line. */
+  cutToEndOfLine(maintainClipboard?: boolean, options?: ReadonlyEditOptions): void;
+
+  /** Cuts the selection until the end of the buffer line. */
+  cutToEndOfBufferLine(maintainClipboard?: boolean, options?: ReadonlyEditOptions): void;
+
+  /** Copies the selection to the clipboard and then deletes it. */
+  cut(maintainClipboard?: boolean, fullLine?: boolean, options?: ReadonlyEditOptions): void;
+
+  /** Copies the current selection to the clipboard. */
+  copy(maintainClipboard?: boolean, fullLine?: boolean): void;
+
+  /** Creates a fold containing the current selection. */
+  fold(): void;
+
+  /** If the selection spans multiple rows, indent all of them. */
+  indentSelectedRows(options?: ReadonlyEditOptions): void;
+
+  // Managing multiple selections
+  /** Moves the selection down one row. */
+  addSelectionBelow(): void;
+
+  /** Moves the selection up one row. */
+  addSelectionAbove(): void;
+
+  /**
+   * Combines the given selection into this selection and then destroys the
+   * given selection.
+   */
+  merge(
+    otherSelection: Selection,
+    options?: { preserveFolds?: boolean | undefined; autoscroll?: boolean | undefined },
+  ): void;
+
+  // Comparing to other selections
+  /**
+   * Compare this selection's buffer range to another selection's buffer range.
+   * See {@link Range#compare} for more details.
+   */
+  compare(otherSelection: Selection): number;
+}
+
+export interface SelectionChangedEvent {
+  oldBufferRange: Range;
+  oldScreenRange: Range;
+  newBufferRange: Range;
+  newScreenRange: Range;
+  selection: Selection;
+}

package/src/style-manager.d.ts

@@ -0,0 +1,68 @@
+import { Disposable } from "../index";
+
+/**
+ *  A singleton instance of this class available via atom.styles, which you can
+ *  use to globally query and observe the set of active style sheets.
+ */
+export interface StyleManager {
+  // Event Subscription
+  /** Invoke callback for all current and future style elements. */
+  observeStyleElements(callback: (styleElement: StyleElementObservedEvent) => void): Disposable;
+
+  /** Invoke callback when a style element is added. */
+  onDidAddStyleElement(callback: (styleElement: StyleElementObservedEvent) => void): Disposable;
+
+  /** Invoke callback when a style element is removed. */
+  onDidRemoveStyleElement(callback: (styleElement: HTMLStyleElement) => void): Disposable;
+
+  /** Invoke callback when an existing style element is updated. */
+  onDidUpdateStyleElement(callback: (styleElement: StyleElementObservedEvent) => void): Disposable;
+
+  // Reading Style Elements
+  /** Get all loaded style elements. */
+  getStyleElements(): HTMLStyleElement[];
+
+  // Paths
+  /** Get the path of the user style sheet in ~/.atom. */
+  getUserStyleSheetPath(): string;
+
+  /**
+   * Add a stylesheet to the workspace.
+   *
+   * The vast majority of users won't have to do this directly.
+   */
+  addStyleSheet(
+    /** The raw CSS to add. */
+    source: string,
+    params: {
+      /**
+       * The path on disk of the original source file from which this CSS was
+       * generated. This acts as a unique identifier for the stylesheet; if an
+       * existing `style` tag exists with the same `sourcePath`, its contents
+       * are replaced instead of a new `style` element being created.
+       */
+      sourcePath?: string
+      context?: string
+      /**
+       * The sheet's priority. The higher the number, the later the placement
+       * in the list of `style` elements.
+       */
+      priority?: number
+      /**
+       * Whether to transform deprecated shadow DOM selectors for greater
+       * compatibility.
+       */
+      skipDeprecatedSelectorsTransformation?: boolean
+      /**
+       * Whether to transform deprecated math usages from Less.js for greater
+       * compatibility.
+       */
+      skipDeprecatedMathUsageTransformation?: boolean
+    }
+  ): Disposable;
+}
+
+export interface StyleElementObservedEvent extends HTMLStyleElement {
+  sourcePath: string;
+  context: string;
+}

package/src/task.d.ts

@@ -0,0 +1,38 @@
+import { Disposable } from "../index";
+
+/** Run a node script in a separate process. */
+export class Task {
+  /** A helper method to easily launch and run a task once. */
+  static once(taskPath: string, ...args: any[]): Task;
+
+  /** Creates a task. You should probably use .once */
+  constructor(taskPath: string);
+
+  /**
+   * Starts the task.
+   *
+   * Throws an error if this task has already been terminated or if sending a
+   * message to the child process fails.
+   */
+  start(...args: any[]): void;
+
+  /**
+   * Sends a message to the task.
+   *
+   * Throws an error if this task has already been terminated or if sending a
+   * message to the child process fails.
+   */
+  send(message: string | number | boolean | object | null | any[]): void;
+
+  /** Call a function when an event is emitted by the child process. */
+  on(eventName: string, callback: (param: any) => void): Disposable;
+
+  /**
+   * Forcefully stop the running task.
+   * No more events are emitted once this method is called.
+   */
+  terminate(): void;
+
+  /** Cancel the running task and emit an event if it was canceled. */
+  cancel(): boolean;
+}

package/src/text-editor-component.d.ts

@@ -0,0 +1,15 @@
+import { PixelPosition, Point, PointLike } from "../index";
+
+/**
+ *  Undocumented: Rendering component for TextEditor
+ */
+export interface TextEditorComponent {
+  /**
+   * Does not clip screenPosition, unlike similar method on
+   * {@link TextEditorElement.}
+   */
+  pixelPositionForScreenPosition(screenPosition: PointLike): PixelPosition;
+  screenPositionForPixelPosition(pos: PixelPosition): Point;
+  pixelPositionForMouseEvent(event: { clientX: number; clientY: number }): PixelPosition;
+  screenPositionForMouseEvent(event: { clientX: number; clientY: number }): Point;
+}

package/src/text-editor-element.d.ts

@@ -0,0 +1,48 @@
+import { Disposable, PixelPosition, PointLike, TextEditor, TextEditorComponent } from "../index";
+
+/**
+ * Undocumented: Custom HTML element for {@link TextEditor}
+ * (`atom-text-editor`).
+ */
+export interface TextEditorElement extends HTMLElement {
+  getModel(): TextEditor;
+  getComponent(): TextEditorComponent;
+  /**
+   * Extended: Get a promise that resolves the next time the element's
+   * DOM is updated in any way.
+   */
+  getNextUpdatePromise(): Promise<void>;
+
+  /** Extended: get the width of an `x` character displayed in this element. */
+  getBaseCharacterWidth(): number;
+
+  /** Essential: Scrolls the editor to the top. */
+  scrollToTop(): void;
+
+  /** Essential: Scrolls the editor to the bottom. */
+  scrollToBottom(): void;
+
+  hasFocus(): boolean;
+
+  setScrollTop(scrollTop: number): void;
+  getScrollTop(): number;
+
+  setScrollLeft(scrollLeft: number): void;
+  getScrollLeft(): number;
+
+  getScrollHeight(): number;
+
+  /** Extended: Converts a buffer position to a pixel position. */
+  pixelPositionForBufferPosition(bufferPosition: PointLike): PixelPosition;
+
+  /** Extended: Converts a screen position to a pixel position. */
+  pixelPositionForScreenPosition(screenPosition: PointLike): PixelPosition;
+
+  // Event subscription
+  onDidChangeScrollTop(callback: (scrollTop: number) => void): Disposable;
+  onDidChangeScrollLeft(callback: (scrollLeft: number) => void): Disposable;
+  /** Called when the editor is attached to the DOM. */
+  onDidAttach(callback: () => void): Disposable;
+  /** Called when the editor is detached from the DOM. */
+  onDidDetach(callback: () => void): Disposable;
+}

package/src/text-editor-registry.d.ts

@@ -0,0 +1,48 @@
+import { Disposable, TextEditor } from "../index";
+
+/** Experimental: This global registry tracks registered TextEditors. */
+export interface TextEditorRegistry {
+  // Managing Text Editors
+  /** Remove all editors from the registry. */
+  clear(): void;
+
+  /** Register a TextEditor. */
+  add(editor: TextEditor): Disposable;
+
+  /** Remove the given TextEditor from the registry. */
+  remove(editor: TextEditor): boolean;
+
+  /** Keep a TextEditor's configuration in sync with Atom's settings. */
+  maintainConfig(editor: TextEditor): Disposable;
+
+  /**
+   * Set a TextEditor's grammar based on its path and content, and continue
+   * to update its grammar as gramamrs are added or updated, or the editor's
+   * file path changes.
+   */
+  maintainGrammar(editor: TextEditor): Disposable;
+
+  /**
+   * Force a TextEditor to use a different grammar than the one that would
+   * otherwise be selected for it.
+   */
+  setGrammarOverride(editor: TextEditor, scopeName: string): void;
+
+  /**
+   * Retrieve the grammar scope name that has been set as a grammar override
+   * for the given TextEditor.
+   */
+  getGrammarOverride(editor: TextEditor): string | null;
+
+  /**
+   * Remove any grammar override that has been set for the given TextEditor.
+   */
+  clearGrammarOverride(editor: TextEditor): void;
+
+  // Event Subscription
+  /**
+   * Invoke the given callback with all the current and future registered
+   * TextEditors.
+   */
+  observe(callback: (editor: TextEditor) => void): Disposable;
+}