@pulsar-edit/types 1.128.1

package/src/buffered-process.d.ts

@@ -0,0 +1,88 @@
+import { ChildProcess } from "child_process";
+import { Disposable, HandleableErrorEvent } from "../index";
+
+/**
+ *  A wrapper which provides standard error/output line buffering for
+ *  Node's ChildProcess.
+ */
+export class BufferedProcess {
+  readonly process?: ChildProcess | undefined;
+
+  constructor(options: ProcessOptions);
+
+  // Event Subscription
+  /**
+   *  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.
+   */
+  onWillThrowError(callback: (errorObject: HandleableErrorEvent) => void): Disposable;
+
+  // Helper Methods
+  /** Terminate the process. */
+  kill(): void;
+
+  /** Runs the process. */
+  start(): void;
+}
+
+export interface NodeProcessOptions {
+  /** The command to execute. */
+  command: string;
+
+  /** The array of arguments to pass to the command. */
+  args?: readonly string[] | undefined;
+
+  /** The options object to pass to Node's ChildProcess.spawn method. */
+  options?: SpawnProcessOptions | undefined;
+
+  /**
+   *  The callback that receives a single argument which contains the standard
+   *  output from the command.
+   */
+  stdout?(data: string): void;
+
+  /**
+   *  The callback that receives a single argument which contains the standard
+   *  error output from the command.
+   */
+  stderr?(data: string): void;
+
+  /** The callback which receives a single argument containing the exit status. */
+  exit?(code: number): void;
+}
+
+export interface ProcessOptions extends NodeProcessOptions {
+  /**
+   *  Whether the command will automatically start when this BufferedProcess is
+   *  created.
+   */
+  autoStart?: boolean | undefined;
+}
+
+export interface SpawnProcessOptions {
+  /** Current working directory of the child process. */
+  cwd?: string | undefined;
+
+  /** Environment key-value pairs. */
+  env?: { [key: string]: string } | undefined;
+
+  /** The child's stdio configuration. */
+  stdio?: string | Array<string | number> | undefined;
+
+  /** Prepare child to run independently of its parent process. */
+  detached?: boolean | undefined;
+
+  /** Sets the user identity of the process. */
+  uid?: number | undefined;
+
+  /** Sets the group identity of the process. */
+  gid?: number | undefined;
+
+  /**
+   *  If true, runs command inside of a shell. Uses "/bin/sh" on UNIX, and process.env.ComSpec
+   *  on Windows. A different shell can be specified as a string.
+   */
+  shell?: boolean | string | undefined;
+}

package/src/clipboard.d.ts

@@ -0,0 +1,14 @@
+/** Represents the clipboard used for copying and pasting in Atom. */
+export interface Clipboard {
+  /** Write the given text to the clipboard. */
+  write(text: string, metadata?: object): void;
+
+  /** Read the text from the clipboard. */
+  read(): string;
+
+  /**
+   *  Read the text from the clipboard and return both the text and the associated
+   *  metadata.
+   */
+  readWithMetadata(): { text: string; metadata: object };
+}

package/src/color.d.ts

@@ -0,0 +1,11 @@
+/**
+ *  A simple color class returned from Config::get when the value at the key path is
+ *  of type 'color'.
+ */
+export interface Color {
+  /** Returns a string in the form '#abcdef'. */
+  toHexString(): string;
+
+  /** Returns a string in the form 'rgba(25, 50, 75, .9)'. */
+  toRGBAString(): string;
+}

package/src/command-registry.d.ts

@@ -0,0 +1,118 @@
+import { CommandEvent, CompositeDisposable, Disposable } from "../index";
+
+export interface CommandRegistryTargetMap extends HTMLElementTagNameMap {
+  [key: string]: EventTarget;
+}
+
+/**
+ * Commands can be bound to specific targets (element nodes that already exist)
+ * or to abstract targets (CSS selectors that describe nodes that may exist now
+ * or may only exist in the future).
+ *
+ * If we have a specific node reference, we can be more explicit about the
+ * types on the `CommandEvent` that will eventually fire. If we have a string,
+ * we only know that the `CommandEvent` will refer to some sort of
+ * `EventTarget`, but cannot be more specific than that.
+ */
+export type CommandRegistryListener<TargetType extends EventTarget = EventTarget> =
+  | {
+    didDispatch(event: CommandEvent<TargetType>): unknown | Promise<unknown>;
+    /**
+     * A custom "humanized" command name that will appear in the command
+     * palette for this command.
+     *
+     * The default humanization algorithm for command names is to title-case
+     * all words; `foo:do-a-cool-thing` becomes `Foo: Do A Cool Thing`. If that
+     * somehow doesn't suffice, you may specify your own humanized name — but
+     * you are encouraged to keep it as similar to the base command name as
+     * possible so that users may enjoy predictable filtering behavior within
+     * the command palette.
+     */
+    displayName?: string | undefined;
+    /**
+     * An optional description to show within the command palette for this
+     * command.
+     *
+     * This is rarely used, but is present in case you want to add more context
+     * to the user around what this command does. It is only used by the
+     * command palette and will display an extra line of text underneath the
+     * humanized command name.
+     */
+    description?: string | undefined;
+    /**
+     * Whether this command should appear in the command palette. Defaults to
+     * `true` if omitted.
+     *
+     * It is rare that you'd want to hide a certain command from appearing in
+     * the command palette, but not unheard of. For instance: a language
+     * grammar may add a command that does something simple while the user
+     * types (like add padding around the cursor or insert a pair of
+     * delimiters) and bind it to a commonly used key. In those cases, it would
+     * be fair to hide such a command from the command palette so as not to
+     * remove it from the specific context in which it would be invoked.
+     */
+    hiddenInCommandPalette?: boolean | undefined;
+  }
+  | ((event: CommandEvent<TargetType>) => unknown | Promise<unknown>);
+
+/**
+ * Associates listener functions with commands in a context-sensitive way using
+ * CSS selectors.
+ */
+export interface CommandRegistry {
+  /** Register a single command. */
+  add<T extends keyof CommandRegistryTargetMap>(
+    target: T,
+    commandName: string,
+    listener: CommandRegistryListener<CommandRegistryTargetMap[T]>,
+  ): Disposable;
+  /** Register a single command. */
+  add<T extends Node>(target: T, commandName: string, listener: CommandRegistryListener<T>): Disposable;
+  /** Register a single command. */
+  add<T extends string>(target: T, commandName: string, listener: CommandRegistryListener): Disposable;
+
+  /** Register multiple commands. */
+  add<T extends keyof CommandRegistryTargetMap>(
+    target: T,
+    commands: {
+      [key: string]: CommandRegistryListener<CommandRegistryTargetMap[T]>;
+    }
+  ): CompositeDisposable;
+  /** Register multiple commands. */
+  add<T extends Node>(
+    target: T,
+    commands: {
+      [key: string]: CommandRegistryListener<T>;
+    }
+  ): CompositeDisposable;
+  add<T extends string>(
+    target: T,
+    commands: {
+      [key: string]: CommandRegistryListener;
+    }
+  ) : CompositeDisposable;
+
+  /** Find all registered commands matching a query. */
+  findCommands(params: {
+    target: string | Node;
+  }): Array<{
+    name: string;
+    displayName: string;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+  }>;
+
+  /**
+   *  Simulate the dispatch of a command on a DOM node.
+   *
+   * @return Either a promise that resolves after all handlers complete or
+   * `null` if no handlers were matched.
+   */
+  dispatch(target: Node, commandName: string): Promise<void> | null;
+
+  /** Invoke the given callback before dispatching a command event. */
+  onWillDispatch(callback: (event: CommandEvent) => void): Disposable;
+
+  /** Invoke the given callback after dispatching a command event. */
+  onDidDispatch(callback: (event: CommandEvent) => void): Disposable;
+}

package/src/config-schema.d.ts

@@ -0,0 +1,271 @@
+import { FileEncoding, Invisibles } from "../index";
+
+// NOTE: The config schema with these defaults can be found here:
+// https://github.com/pulsar-edit/pulsar/blob/v1.128.0/src/config-schema.js
+/**
+ * Allows you to strongly type Atom configuration variables. Additional
+ * key/value pairings merged into this interface will result in configuration
+ * values under the value of each key being templated by the type of the
+ * associated value.
+ */
+export interface ConfigValues {
+  // NOTE: this is intentionally left empty, extended via ambient declarations
+}
+
+// NOTE: A hack to make ConfigValues extensible.
+declare module "atom" {
+  interface ConfigValues {
+    /**
+     * List of glob patterns. Files and directories matching these patterns
+     * will be ignored by some packages, such as the fuzzy finder and tree
+     * view. Individual packages might have additional config settings for
+     * ignoring names.
+     */
+    "core.ignoredNames": string[];
+
+    /**
+     * Files and directories ignored by the current project's VCS system will
+     * be ignored by some packages, such as the fuzzy finder and find and
+     * replace. For example, projects using Git have these paths defined in the
+     * .gitignore file. Individual packages might have additional config
+     * settings for ignoring VCS ignored files and folders.
+     */
+    "core.excludeVcsIgnoredPaths": boolean;
+
+    /**
+     * Follow symbolic links when searching files and when opening files with
+     * the fuzzy finder.
+     */
+    "core.followSymlinks": boolean;
+
+    /** List of names of installed packages which are not loaded at startup. */
+    "core.disabledPackages": string[];
+
+    /** List of names of installed packages which are not automatically updated. */
+    "core.versionPinnedPackages": string[];
+
+    /**
+     * Associates scope names (e.g. "source.coffee") with arrays of file
+     * extensions and file names (e.g. ["Cakefile", ".coffee2"]). */
+    "core.customFileTypes": {
+      [key: string]: string[];
+    };
+
+    /** Names of UI and syntax themes which will be used when Atom starts. */
+    "core.themes": string[];
+
+    /**
+     * Trigger the system's beep sound when certain actions cannot be executed
+     * or there are no results.
+     */
+    "core.audioBeep": boolean;
+
+    /** Close corresponding editors when a file is deleted outside Atom. */
+    "core.closeDeletedFileTabs": boolean;
+
+    /** When the last tab of a pane is closed, remove that pane as well. */
+    "core.destroyEmptyPanes": boolean;
+
+    /**
+     * When a window with no open tabs or panes is given the 'Close Tab'
+     * command, close that window.
+     */
+    "core.closeEmptyWindows": boolean;
+
+    /** Default character set encoding to use when reading and writing files. */
+    "core.fileEncoding": FileEncoding;
+
+    /**
+     * When checked, opens an untitled editor when loading a blank environment
+     * (such as with 'File > New Window' or when "Restore Previous Windows On
+     * Start" is unchecked); otherwise, no editor is opened when loading a
+     * blank environment. This setting has no effect when restoring a previous
+     * state.
+     */
+    "core.openEmptyEditorOnStart": boolean;
+
+    /**
+     * When 'no': loads a blank environment.
+     *
+     * When 'yes', and Pulsar is started from the icon or `pulsar` by itself
+     * from the command line, restores the last state of all Pulsar windows;
+     * otherwise, loads a blank environment.
+     *
+     * When 'always', restores the last state of all Pulsar windows always, no
+     * matter how Pulsar is started.
+     */
+    "core.restorePreviousWindowsOnStart": "no" | "yes" | "always";
+
+    /** How many recent projects to show in the Reopen Project menu. */
+    "core.reopenProjectMenuCount": number;
+
+    /** Automatically update Atom when a new release is available. */
+    "core.automaticallyUpdate": boolean;
+
+    /** Use detected proxy settings when calling the `apm` command-line tool. */
+    "core.useProxySettingsWhenCallingApm": boolean;
+
+    /**
+     * Allow items to be previewed without adding them to a pane permanently,
+     * such as when single clicking files in the tree view.
+     */
+    "core.allowPendingPaneItems": boolean;
+
+    /**
+     * Allow usage statistics and exception reports to be sent to the Pulsar
+     * team to help improve the product.
+     */
+    "core.telemetryConsent": "limited" | "no" | "undecided";
+
+    /** Warn before opening files larger than this number of megabytes. */
+    "core.warnOnLargeFileLimit": number;
+
+    /**
+     * Choose the underlying implementation used to watch for filesystem
+     * changes. Emulating changes will miss any events caused by applications
+     * other than Atom, but may help prevent crashes or freezes.
+     */
+    "core.fileSystemWatcher": "native";
+
+    /** Use new Tree-sitter parsing system for supported languages. */
+    "core.useTreeSitterParsers": boolean;
+
+    /**
+     * Specify whether Atom should use the operating system's color profile
+     * (recommended) or an alternative color profile.
+     */
+    "core.colorProfile": "default" | "srgb";
+
+    "editor.commentStart": string | null;
+
+    "editor.commentEnd": string | null;
+
+    "editor.increaseIndentPattern": string | null;
+
+    "editor.decreaseIndentPattern": string | null;
+
+    "editor.foldEndPattern": string | null;
+
+    /** The name of the font family used for editor text. */
+    "editor.fontFamily": string;
+
+    /** Height in pixels of editor text. */
+    "editor.fontSize": number;
+
+    /** Height of editor lines, as a multiplier of font size. */
+    "editor.lineHeight": string | number;
+
+    /** Show cursor while there is a selection. */
+    "editor.showCursorOnSelection": boolean;
+
+    /** Render placeholders for invisible characters, such as tabs, spaces and newlines. */
+    "editor.showInvisibles": boolean;
+
+    /** Show indentation indicators in the editor. */
+    "editor.showIndentGuide": boolean;
+
+    /** Show line numbers in the editor's gutter. */
+    "editor.showLineNumbers": boolean;
+
+    /** Skip over tab-length runs of leading whitespace when moving the cursor. */
+    "editor.atomicSoftTabs": boolean;
+
+    /** Automatically indent the cursor when inserting a newline. */
+    "editor.autoIndent": boolean;
+
+    /** Automatically indent pasted text based on the indentation of the previous line. */
+    "editor.autoIndentOnPaste": boolean;
+
+    /** A string of non-word characters to define word boundaries. */
+    "editor.nonWordCharacters": string;
+
+    /**
+     * Identifies the length of a line which is used when wrapping text with
+     * the `Soft Wrap At Preferred Line Length` setting enabled, in number of
+     * characters.
+     */
+    "editor.preferredLineLength": number;
+
+    /**
+     * Defines the maximum width of the editor window before soft wrapping is
+     * enforced, in number of characters.
+     */
+    "editor.maxScreenLineLength": number;
+
+    /** Number of spaces used to represent a tab. */
+    "editor.tabLength": number;
+
+    /**
+     * Wraps lines that exceed the width of the window. When `Soft Wrap At
+     * Preferred Line Length` is set, it will wrap to the number of characters
+     * defined by the `Preferred Line Length` setting.
+     */
+    "editor.softWrap": boolean;
+
+    /**
+     * If the `Tab Type` config setting is set to "auto" and autodetection of
+     * tab type from buffer content fails, then this config setting determines
+     * whether a soft tab or a hard tab will be inserted when the Tab key is
+     * pressed.
+     */
+    "editor.softTabs": boolean;
+
+    /**
+     * Determine character inserted when Tab key is pressed. Possible values:
+     * "auto", "soft" and "hard". When set to "soft" or "hard", soft tabs
+     * (spaces) or hard tabs (tab characters) are used. When set to "auto", the
+     * editor auto-detects the tab type based on the contents of the buffer (it
+     * uses the first leading whitespace on a non-comment line), or uses the
+     * value of the Soft Tabs config setting if auto-detection fails.
+     */
+    "editor.tabType": "auto" | "soft" | "hard";
+
+    /**
+     * Instead of wrapping lines to the window's width, wrap lines to the
+     * number of characters defined by the `Preferred Line Length` setting.
+     * This will only take effect when the soft wrap config setting is enabled
+     * globally or for the current language. **Note:** If you want to hide the
+     * wrap guide (the vertical line) you can disable the `wrap-guide` package.
+     */
+    "editor.softWrapAtPreferredLineLength": boolean;
+
+    /**
+     * When soft wrap is enabled, defines length of additional indentation
+     * applied to wrapped lines, in number of characters.
+     */
+    "editor.softWrapHangingIndent": number;
+
+    /** Determines how fast the editor scrolls when using a mouse or trackpad. */
+    "editor.scrollSensitivity": number;
+
+    /** Allow the editor to be scrolled past the end of the last line. */
+    "editor.scrollPastEnd": boolean;
+
+    /**
+     * Time interval in milliseconds within which text editing operations will
+     * be grouped together in the undo history.
+     */
+    "editor.undoGroupingInterval": number;
+
+    /**
+     * Show confirmation dialog when checking out the HEAD revision and
+     * discarding changes to current file since last commit.
+     */
+    "editor.confirmCheckoutHeadRevision": boolean;
+
+    /**
+     * A hash of characters Atom will use to render whitespace characters. Keys
+     * are whitespace character types, values are rendered characters (use
+     * value false to turn off individual whitespace character types).
+     */
+    "editor.invisibles": Invisibles;
+
+    /**
+     * Change the editor font size when pressing the Ctrl key and scrolling the
+     * mouse up/down.
+     */
+    "editor.zoomFontWhenCtrlScrolling": boolean;
+
+    [key: string]: any;
+  }
+}

package/src/config.d.ts

@@ -0,0 +1,168 @@
+import { ConfigValues, Disposable, ScopeDescriptor } from "../index";
+
+type ConfigSchemaType = 'integer' | 'boolean' | 'array' | 'object' | 'color' | 'string' | 'number'
+
+export type ConfigSchema =
+  | ConfigSchemaForInteger
+  | ConfigSchemaForNumber
+  | ConfigSchemaForBoolean
+  | ConfigSchemaForArray
+  | ConfigSchemaForString
+  | ConfigSchemaForColor
+  | ConfigSchemaForObject
+
+type ConfigSchemaBase = {
+  title?: string
+  description?: string
+}
+
+type ConfigSchemaForInteger = ConfigSchemaBase & {
+  type: 'integer'
+  default?: number
+  minimum?: number
+  maximum?: number
+}
+
+type ConfigSchemaForNumber = ConfigSchemaBase & {
+  type: 'number'
+  default?: number
+  minimum?: number
+  maximum?: number
+}
+
+type ConfigSchemaForBoolean = ConfigSchemaBase & {
+  type: 'boolean'
+  default?: boolean
+}
+
+type ConfigSchemaForString = {
+  type: 'string'
+  default?: string
+}
+
+type ConfigSchemaForColor = {
+  type: 'color'
+  default?: string
+}
+
+type ConfigSchemaForArray<SubType = unknown> = ConfigSchemaBase & {
+  type: 'array'
+  default?: SubType[]
+  items: ConfigSchema
+}
+
+type ConfigSchemaForObject = ConfigSchemaBase & {
+  type: 'object'
+  properties: Record<string, ConfigSchema>
+}
+
+/** Used to access all of Atom's configuration details. */
+export interface Config {
+  // Config Subscription
+  /**
+   * Add a listener for changes to a given key path.
+   *
+   * This is different than {@link onDidChange} in that it will immediately
+   * call your callback with the current value of the config entry.
+   */
+  observe<T extends keyof ConfigValues>(keyPath: T, callback: (value: ConfigValues[T]) => void): Disposable;
+  /**
+   * Add a listener for changes to a given key path.
+   *
+   * This is different than {@link onDidChange} in that it will immediately
+   * call your callback with the current value of the config entry.
+   */
+  observe<T extends keyof ConfigValues>(
+    keyPath: T,
+    options: { scope: string[] | ScopeDescriptor },
+    callback: (value: ConfigValues[T]) => void,
+  ): Disposable;
+
+  /**
+   * Add a listener for all configuration key changes.
+   */
+  // tslint:disable-next-line:no-any
+  onDidChange<T = any>(
+    callback: (values: { newValue: T; oldValue: T }) => void
+  ): Disposable;
+  /**
+   * Add a listener for changes to a given key path.
+   */
+  onDidChange<T extends keyof ConfigValues>(
+    keyPath: T,
+    callback: (values: { newValue: ConfigValues[T]; oldValue?: ConfigValues[T] | undefined }) => void,
+  ): Disposable;
+  /**
+   * Add a listener for changes to a given key path.
+   */
+  onDidChange<T extends keyof ConfigValues>(
+    keyPath: T,
+    options: { scope: string[] | ScopeDescriptor },
+    callback: (values: { newValue: ConfigValues[T]; oldValue?: ConfigValues[T] | undefined }) => void,
+  ): Disposable;
+
+  // Managing Settings
+  /** Retrieves the setting for the given key. */
+  get<T extends keyof ConfigValues>(
+    keyPath: T,
+    options?: {
+      sources?: string[] | undefined;
+      excludeSources?: string[] | undefined;
+      scope?: string[] | ScopeDescriptor | undefined;
+    },
+  ): ConfigValues[T];
+
+  /**
+   * Sets the value for a configuration setting.
+   *
+   * Unless the `source` option is specified, this value is stored in Atom's
+   * internal configuration file.
+   */
+  set<T extends keyof ConfigValues>(
+    keyPath: T,
+    value: ConfigValues[T],
+    options?: { scopeSelector?: string | undefined; source?: string | undefined },
+  ): void;
+
+  /** Restore the setting at `keyPath` to its default value. */
+  unset(keyPath: string, options?: { scopeSelector?: string | undefined; source?: string | undefined }): void;
+
+  /**
+   * Get all of the values for the given key path, along with their associated
+   * scope selector.
+   */
+  getAll<T extends keyof ConfigValues>(
+    keyPath: T,
+    options?: {
+      sources?: string[] | undefined;
+      excludeSources?: string[] | undefined;
+      scope?: ScopeDescriptor | undefined;
+    },
+  ): Array<{ scopeDescriptor: ScopeDescriptor; value: ConfigValues[T] }>;
+
+  /**
+   * Get an Array of all of the source strings with which settings have been
+   * added via {@link set}.
+   */
+  getSources(): string[];
+
+  /**
+   * Retrieve the schema for a specific key path.
+   *
+   * The schema will tell you what type the keyPath expects, and other metadata
+   * about the config option.
+   */
+  getSchema(keyPath: string): ConfigSchema | null;
+
+  /** Get the string path to the config file being used. */
+  getUserConfigPath(): string;
+
+  /**
+   * Suppress calls to handler functions registered with {@link onDidChange}
+   * and {@link observe} for the duration of `callback`.
+   *
+   * After `callback` executes, handlers will be called once if the value for
+   * their key path has changed.
+   */
+  transact(callback: () => void): void;
+}