@pulsar-edit/types 1.128.1

package/src/context-menu-manager.d.ts

@@ -0,0 +1,65 @@
+import { Disposable } from "../index";
+
+/**
+ * Provides a registry for commands that you'd like to appear in the context
+ * menu.
+ */
+export interface ContextMenuManager {
+  /** Add context menu items scoped by CSS selectors. */
+  add(itemsBySelector: { [key: string]: readonly ContextMenuOptions[] }): Disposable;
+}
+
+export type ContextMenuOptions = ContextMenuItemOptions | { type: "separator" };
+
+export interface ContextMenuItemOptions {
+  /** The menu item's label. */
+  label?: string | undefined;
+
+  /**
+   * The command to invoke on the target of the right click that invoked the
+   * context menu.
+   */
+  command?: string | undefined;
+
+  /**
+   * Whether the menu item should be clickable. Disabled menu items typically
+   * appear grayed out. Defaults to `true`.
+   */
+  enabled?: boolean | undefined;
+
+  /** An array of additional items. */
+  submenu?: readonly ContextMenuOptions[] | undefined;
+
+  /** Whether the menu item should appear in the menu. Defaults to `true`. */
+  visible?: boolean | undefined;
+
+  /**
+   * A function that is called on the item each time a context menu is created
+   * via a right click.
+   */
+  created?(event: Event): void;
+
+  /**
+   * A function that is called to determine whether to display this item on a
+   * given context menu deployment.
+   */
+  shouldDisplay?(event: Event): void;
+
+  /** Place this menu item before the menu items representing the given commands. */
+  before?: readonly string[] | undefined;
+
+  /** Place this menu item after the menu items representing the given commands. */
+  after?: readonly string[] | undefined;
+
+  /**
+   * Place this menu item's group before the containing group of the menu items
+   * representing the given commands.
+   */
+  beforeGroupContaining?: readonly string[] | undefined;
+
+  /**
+   * Place this menu item's group after the containing group of the menu items
+   * representing the given commands.
+   */
+  afterGroupContaining?: readonly string[] | undefined;
+}

package/src/cursor.d.ts

@@ -0,0 +1,252 @@
+import { DisplayMarker, Disposable, Point, PointCompatible, Range, ScopeDescriptor } from "../index";
+
+/**
+ *  The Cursor class represents the little blinking line identifying where text
+ *  can be inserted.
+ */
+export interface Cursor {
+  // Event Subscription
+  /** Calls your callback when the cursor has been moved. */
+  onDidChangePosition(callback: (event: CursorPositionChangedEvent) => void): Disposable;
+
+  /** Calls your callback when the cursor is destroyed. */
+  onDidDestroy(callback: () => void): Disposable;
+
+  /** Calls your callback when the cursor's visibility has changed. */
+  onDidChangeVisibility(callback: (visibility: boolean) => void): Disposable;
+
+  // Managing Cursor Position
+  /** Moves a cursor to a given screen position. */
+  setScreenPosition(screenPosition: PointCompatible, options?: { autoscroll?: boolean | undefined }): void;
+
+  /** Returns the screen position of the cursor as a Point. */
+  getScreenPosition(): Point;
+
+  /** Moves a cursor to a given buffer position. */
+  setBufferPosition(bufferPosition: PointCompatible, options?: { autoscroll?: boolean | undefined }): void;
+
+  /** Returns the current buffer position as an Array. */
+  getBufferPosition(): Point;
+
+  /** Returns the cursor's current screen row. */
+  getScreenRow(): number;
+
+  /** Returns the cursor's current screen column. */
+  getScreenColumn(): number;
+
+  /** Retrieves the cursor's current buffer row. */
+  getBufferRow(): number;
+
+  /** Returns the cursor's current buffer column. */
+  getBufferColumn(): number;
+
+  /** Returns the cursor's current buffer row of text excluding its line ending. */
+  getCurrentBufferLine(): string;
+
+  /** Returns whether the cursor is at the start of a line. */
+  isAtBeginningOfLine(): boolean;
+
+  /** Returns whether the cursor is on the line return character. */
+  isAtEndOfLine(): boolean;
+
+  // Cursor Position Details
+  /**
+   * Returns the underlying DisplayMarker for the cursor.
+   *
+   * Useful with overlay decorations.
+   */
+  getMarker(): DisplayMarker;
+
+  /**
+   * Identifies if the cursor is surrounded by whitespace.
+   *
+   * "Surrounded" means that the character directly before and after the cursor
+   * are both whitespace.
+   */
+  isSurroundedByWhitespace(): boolean;
+
+  /**
+   * Returns whether the cursor is currently between a word and non-word
+   * character.
+   *
+   * The non-word characters are defined by the `editor.nonWordCharacters`
+   * config value.
+   *
+   * Returns `false` if the character before or after the cursor is whitespace.
+   */
+  isBetweenWordAndNonWord(): boolean;
+
+  /** Returns whether this cursor is between a word's start and end. */
+  isInsideWord(options?: { wordRegex?: RegExp | undefined }): boolean;
+
+  /** Returns the indentation level of the current line. */
+  getIndentLevel(): number;
+
+  /** Retrieves the scope descriptor for the cursor's current position. */
+  getScopeDescriptor(): ScopeDescriptor;
+
+  /**
+   * Retrieves the syntax tree scope descriptor for the cursor's current
+   * position.
+   */
+  getSyntaxTreeScopeDescriptor(): ScopeDescriptor;
+
+  /**
+   * Returns true if this cursor has no non-whitespace characters before its
+   * current position.
+   */
+  hasPrecedingCharactersOnLine(): boolean;
+
+  /**
+   * Identifies if this cursor is the last in the TextEditor.
+   *
+   * "Last" is defined as the most recently added cursor.
+   */
+  isLastCursor(): boolean;
+
+  // Moving the Cursor
+  /** Moves the cursor up one screen row. */
+  moveUp(rowCount?: number, options?: { moveToEndOfSelection?: boolean | undefined }): void;
+
+  /** Moves the cursor down one screen row. */
+  moveDown(rowCount?: number, options?: { moveToEndOfSelection?: boolean | undefined }): void;
+
+  /** Moves the cursor left one screen column. */
+  moveLeft(columnCount?: number, options?: { moveToEndOfSelection?: boolean | undefined }): void;
+
+  /** Moves the cursor right one screen column. */
+  moveRight(columnCount?: number, options?: { moveToEndOfSelection?: boolean | undefined }): void;
+
+  /** Moves the cursor to the top of the buffer. */
+  moveToTop(): void;
+
+  /** Moves the cursor to the bottom of the buffer. */
+  moveToBottom(): void;
+
+  /** Moves the cursor to the beginning of the line. */
+  moveToBeginningOfScreenLine(): void;
+
+  /** Moves the cursor to the beginning of the buffer line. */
+  moveToBeginningOfLine(): void;
+
+  /** Moves the cursor to the beginning of the first character in the line. */
+  moveToFirstCharacterOfLine(): void;
+
+  /** Moves the cursor to the end of the line. */
+  moveToEndOfScreenLine(): void;
+
+  /** Moves the cursor to the end of the buffer line. */
+  moveToEndOfLine(): void;
+
+  /** Moves the cursor to the beginning of the word. */
+  moveToBeginningOfWord(): void;
+
+  /** Moves the cursor to the end of the word. */
+  moveToEndOfWord(): void;
+
+  /** Moves the cursor to the beginning of the next word. */
+  moveToBeginningOfNextWord(): void;
+
+  /** Moves the cursor to the previous word boundary. */
+  moveToPreviousWordBoundary(): void;
+
+  /** Moves the cursor to the next word boundary. */
+  moveToNextWordBoundary(): void;
+
+  /** Moves the cursor to the previous subword boundary. */
+  moveToPreviousSubwordBoundary(): void;
+
+  /** Moves the cursor to the next subword boundary. */
+  moveToNextSubwordBoundary(): void;
+
+  /** Moves the cursor to the beginning of the buffer line, skipping all whitespace. */
+  skipLeadingWhitespace(): void;
+
+  /** Moves the cursor to the beginning of the next paragraph. */
+  moveToBeginningOfNextParagraph(): void;
+
+  /** Moves the cursor to the beginning of the previous paragraph. */
+  moveToBeginningOfPreviousParagraph(): void;
+
+  // Local Positions and Ranges
+  /**
+   * Returns buffer position of previous word boundary. It might be on the
+   * current word, or the previous word.
+   */
+  getPreviousWordBoundaryBufferPosition(options?: { wordRegex?: RegExp | undefined }): Point;
+
+  /**
+   * Returns buffer position of the next word boundary. It might be on the
+   * current word, or the previous word.
+   */
+  getNextWordBoundaryBufferPosition(options?: { wordRegex?: RegExp | undefined }): Point;
+
+  /** Retrieves the buffer position of where the current word starts. */
+  getBeginningOfCurrentWordBufferPosition(options?: {
+    wordRegex?: RegExp | undefined;
+    includeNonWordCharacters?: boolean | undefined;
+    allowPrevious?: boolean | undefined;
+  }): Point;
+
+  /** Retrieves the buffer position of where the current word ends. */
+  getEndOfCurrentWordBufferPosition(
+    options?: { wordRegex?: RegExp | undefined; includeNonWordCharacters?: boolean | undefined },
+  ): Point;
+
+  /** Retrieves the buffer position of where the next word starts. */
+  getBeginningOfNextWordBufferPosition(options?: { wordRegex?: RegExp | undefined }): Point;
+
+  /** Returns the buffer Range occupied by the word located under the cursor. */
+  getCurrentWordBufferRange(options?: { wordRegex?: RegExp | undefined }): Range;
+
+  /** Returns the buffer Range for the current line. */
+  getCurrentLineBufferRange(options?: { includeNewline?: boolean | undefined }): Range;
+
+  /**
+   * Retrieves the range for the current paragraph.
+   *
+   * A paragraph is defined as a block of text surrounded by empty lines or
+   * comments.
+   */
+  getCurrentParagraphBufferRange(): Range;
+
+  /** Returns the characters preceding the cursor in the current word. */
+  getCurrentWordPrefix(): string;
+
+  // Visibility
+  /** Sets whether the cursor is visible. */
+  setVisible(visible: boolean): void;
+
+  /** Returns the visibility of the cursor. */
+  isVisible(): boolean;
+
+  // Comparing to another cursor
+  /**
+   * Compare this cursor's buffer position to another cursor's buffer position.
+   *
+   * See {@link Point#compare} for more details.
+   */
+  compare(otherCursor: Cursor): number;
+
+  // Utilities
+  /** Prevents this cursor from causing scrolling. */
+  clearAutoscroll(): void;
+
+  /** Deselects the current selection. */
+  clearSelection(): void;
+
+  /** Get the RegExp used by the cursor to determine what a "word" is. */
+  wordRegExp(options?: { includeNonWordCharacters?: boolean | undefined }): RegExp;
+
+  /** Get the RegExp used by the cursor to determine what a "subword" is. */
+  subwordRegExp(options?: { backwards?: boolean | undefined }): RegExp;
+}
+
+export interface CursorPositionChangedEvent {
+  oldBufferPosition: Point;
+  oldScreenPosition: Point;
+  newBufferPosition: Point;
+  newScreenPosition: Point;
+  textChanged: boolean;
+  cursor: Cursor;
+}

package/src/decoration.d.ts

@@ -0,0 +1,156 @@
+import { DecorationPropsChangedEvent, DisplayMarker, Disposable } from "../index";
+
+/**
+ * Represents a decoration that follows a {@link DisplayMarker}.
+ *
+ * A decoration is a visual representation of a marker. It allows you to add
+ * CSS classes to line numbers in the gutter, lines, and add selection-line
+ * regions around marked ranges of text.
+ */
+export interface Decoration {
+  /** The identifier for this Decoration. */
+  readonly id: number;
+
+  // Construction and Destruction
+  /**
+   * Destroy this marker decoration.
+   *
+   * If you own the associated marker, you can destroy that instead, and this
+   * decoration will automatically be destroyed.
+   */
+  destroy(): void;
+
+  // Event Subscription
+  /**
+   * Add a listener for when the decoration is updated via
+   * {@link setProperties}.
+   */
+  onDidChangeProperties(callback: (event: DecorationPropsChangedEvent) => void): Disposable;
+
+  /** Add a listener for when this decoration is destroyed. */
+  onDidDestroy(callback: () => void): Disposable;
+
+  // Decoration Details
+  /** An ID unique across all Decoration objects. */
+  getId(): number;
+
+  /** Returns the marker associated with this decoration. */
+  getMarker(): DisplayMarker;
+
+  /**
+   * Check if this decoration is of the given type.
+   *
+   * @param type A decoration type, such as `line-number` or `line`. This may
+   *   also be an array of decoration types, with isType returning true if
+   *   the decoration's type matches any in the array.
+   */
+  isType(type: string | string[]): boolean;
+
+  // Properties
+  /** Returns the Decoration's properties. */
+  getProperties(): DecorationOptions;
+
+  /**
+   * Update the marker with new properties.
+   *
+   * Allows you to change the decoration's class.
+   */
+  setProperties(newProperties: DecorationOptions): void;
+}
+
+export interface SharedDecorationOptions {
+  /**
+   * This CSS class will be applied to the decorated line number, line,
+   * highlight, or overlay.
+   */
+  class?: string | undefined;
+
+  /**
+   * An Object containing CSS style properties to apply to the relevant DOM
+   * node.
+   *
+   * Currently this only works with a type of `cursor` or `text`.
+   */
+  style?: object | undefined;
+
+  /**
+   * An `HTMLElement` or a model object with a corresponding view registered.
+   *
+   * Only applicable to the `gutter`, `overlay`, and `block` types.
+   */
+  item?: object | undefined;
+
+  /**
+   * If `true`, the decoration will only be applied to the head of the
+   * DisplayMarker.
+   *
+   * Only applicable to the `line` and `line-number` types.
+   */
+  onlyHead?: boolean | undefined;
+
+  /**
+   * If `true`, the decoration will only be applied if the associated
+   * DisplayMarker is empty.
+   *
+   * Only applicable to the `gutter`, `line`, and `line-number` types.
+   */
+  onlyEmpty?: boolean | undefined;
+
+  /**
+   * If `true`, the decoration will only be applied if the associated
+   * DisplayMarker is non-empty.
+   *
+   * Only applicable to the `gutter`, `line`, and `line-number` types.
+   */
+  onlyNonEmpty?: boolean | undefined;
+
+  /**
+   * If `false`, the decoration will be applied to the last row of a non-empty
+   * range, even if it ends at column 0.
+   *
+   * Defaults to `true`. Only applicable to the `gutter`, `line`, and
+   * `line-number` types.
+   */
+  omitEmptyLastRow?: boolean | undefined;
+
+  /**
+   * Controls where the view is positioned relative to the TextEditorMarker.
+   *
+   * Values can be 'head' (the default) or 'tail' for overlay decorations, and
+   * 'before' (the default) or 'after' for block decorations.
+   *
+   * Only applicable to the `overlay` and `block` decoration types.
+   */
+  position?: "head" | "tail" | "before" | "after" | undefined;
+
+  /**
+   * Controls where the view is positioned relative to other block decorations
+   * at the same screen row.
+   *
+   * If unspecified, block decorations render oldest to newest. Only applicable
+   * to the `block` type.
+   */
+  order?: number | undefined;
+
+  /**
+   * Determines whether the decoration adjusts its horizontal or vertical
+   * position to remain fully visible when it would otherwise overflow the
+   * editor.
+   *
+   * Defaults to `true`. Only applicable to the `overlay` type.
+   */
+  avoidOverflow?: boolean | undefined;
+}
+
+export interface DecorationLayerOptions extends SharedDecorationOptions {
+  /** One of several supported decoration types. */
+  type?: "line" | "line-number" | "text" | "highlight" | "block" | "cursor" | undefined;
+}
+
+export interface DecorationOptions extends SharedDecorationOptions {
+  /** One of several supported decoration types. */
+  type?: "line" | "line-number" | "text" | "highlight" | "overlay" | "gutter" | "block" | "cursor" | undefined;
+
+  /** The name of the gutter we're decorating, if type is "gutter". */
+  gutterName?: string | undefined;
+}

package/src/deserializer-manager.d.ts

@@ -0,0 +1,15 @@
+import { Disposable } from "../index";
+
+/** Manages the deserializers used for serialized state. */
+export interface DeserializerManager {
+  /** Register the given class(es) as deserializers. */
+  add(...deserializers: Deserializer[]): Disposable;
+
+  /** Deserialize the state and params. */
+  deserialize(state: object): object | undefined;
+}
+
+export interface Deserializer {
+  name: string;
+  deserialize(state: object): object;
+}

package/src/dock.d.ts

@@ -0,0 +1,121 @@
+import { Disposable, Pane, PaneItemObservedEvent } from "../index";
+
+/** A container at the edges of the editor window capable of holding items. */
+export interface Dock {
+  // Methods
+  /** Show the dock and focus its active Pane. */
+  activate(): void;
+
+  /** Show the dock without focusing it. */
+  show(): void;
+
+  /**
+   * Hide the dock and activate the WorkspaceCenter if the dock was was
+   * previously focused.
+   */
+  hide(): void;
+
+  /**
+   * Toggle the dock's visibility without changing the Workspace's active pane
+   * container.
+   */
+  toggle(): void;
+
+  /** Check if the dock is visible. */
+  isVisible(): boolean;
+
+  // Event Subscription
+  /** Invoke the given callback when the visibility of the dock changes. */
+  onDidChangeVisible(callback: (visible: boolean) => void): Disposable;
+
+  /**
+   * Invoke the given callback with the current and all future visibilities of
+   * the dock.
+   */
+  observeVisible(callback: (visible: boolean) => void): Disposable;
+
+  /** Invoke the given callback with all current and future panes items in the dock. */
+  observePaneItems(callback: (item: object) => void): Disposable;
+
+  /**
+   *  Invoke the given callback when the active pane item changes.
+   *
+   *  Because observers are invoked synchronously, it's important not to perform any
+   *  expensive operations via this method. Consider ::onDidStopChangingActivePaneItem
+   *  to delay operations until after changes stop occurring.
+   */
+  onDidChangeActivePaneItem(callback: (item: object) => void): Disposable;
+
+  /** Invoke the given callback when the active pane item stops changing. */
+  onDidStopChangingActivePaneItem(callback: (item: object) => void): Disposable;
+
+  /**
+   *  Invoke the given callback with the current active pane item and with all future
+   *  active pane items in the dock.
+   */
+  observeActivePaneItem(callback: (item: object) => void): Disposable;
+
+  /** Invoke the given callback when a pane is added to the dock. */
+  onDidAddPane(callback: (event: { pane: Pane }) => void): Disposable;
+
+  /** Invoke the given callback before a pane is destroyed in the dock. */
+  onWillDestroyPane(callback: (event: { pane: Pane }) => void): Disposable;
+
+  /** Invoke the given callback when a pane is destroyed in the dock. */
+  onDidDestroyPane(callback: (event: { pane: Pane }) => void): Disposable;
+
+  /** Invoke the given callback with all current and future panes in the dock. */
+  observePanes(callback: (pane: Pane) => void): Disposable;
+
+  /** Invoke the given callback when the active pane changes. */
+  onDidChangeActivePane(callback: (pane: Pane) => void): Disposable;
+
+  /**
+   *  Invoke the given callback with the current active pane and when the active
+   *  pane changes.
+   */
+  observeActivePane(callback: (pane: Pane) => void): Disposable;
+
+  /** Invoke the given callback when a pane item is added to the dock. */
+  onDidAddPaneItem(callback: (event: PaneItemObservedEvent) => void): Disposable;
+
+  /**
+   * Invoke the given callback when a pane item is about to be destroyed,
+   * before the user is prompted to save it.
+   *
+   * @param callback The function to be called before pane items are destroyed.
+   *   If this function returns a Promise, then the item will not be destroyed
+   *   until the promise resolves.
+   */
+  onWillDestroyPaneItem(callback: (event: PaneItemObservedEvent) => void | Promise<void>): Disposable;
+
+  /** Invoke the given callback when a pane item is destroyed. */
+  onDidDestroyPaneItem(callback: (event: PaneItemObservedEvent) => void): Disposable;
+
+  /**
+   * Invoke the given callback when the hovered state of the dock changes.
+   *
+   * @param hovered Is the dock now hovered?
+   */
+  onDidChangeHovered(callback: (hovered: boolean) => void): Disposable;
+
+  // Pane Items
+  /** Get all pane items in the dock. */
+  getPaneItems(): object[];
+
+  /** Get the active Pane's active item. */
+  getActivePaneItem(): object;
+
+  // Panes
+  /** Returns an Array of Panes. */
+  getPanes(): Pane[];
+
+  /** Get the active Pane. */
+  getActivePane(): Pane;
+
+  /** Make the next pane active. */
+  activateNextPane(): boolean;
+
+  /** Make the previous pane active. */
+  activatePreviousPane(): boolean;
+}

package/src/get-window-load-settings.d.ts

@@ -0,0 +1,26 @@
+type LocationToOpen = {
+  exists: boolean;
+  hasWaitSession: boolean;
+  initialColumn: number | null;
+  initialLine: number | null;
+  isDirectory: boolean;
+  isFile: boolean;
+  pathToOpen: string | null;
+};
+
+export interface WindowLoadSettings {
+  readonly appName: string;
+  readonly appVersion: string;
+  readonly atomHome: string;
+  readonly clearWindowState: boolean;
+  readonly devMode: boolean;
+  readonly env?: { [key: string]: string | undefined } | undefined;
+  readonly hasOpenFiles: boolean;
+  readonly initialProjectRoots: string[];
+  readonly locationsToOpen: LocationToOpen[];
+  readonly resourcePath: string;
+  readonly safeMode: boolean;
+  readonly profileStartup?: boolean | undefined;
+  readonly userSettings: object;
+  readonly windowInitializationScript: string;
+}