@pulsar-edit/types 1.128.1

package/dependencies/event-kit/index.d.ts

@@ -0,0 +1,143 @@
+export interface DisposableLike {
+  dispose(): void;
+}
+
+/** A handle to a resource that can be disposed. */
+export class Disposable implements DisposableLike {
+  /** Ensure that Object correctly implements the Disposable contract. */
+  static isDisposable(object: object): boolean;
+
+  /** Construct a Disposable. */
+  constructor(disposableAction?: () => void);
+
+  /** A callback which will be called within dispose(). */
+  disposalAction?(): void;
+
+  /**
+   * Perform the disposal action, indicating that the resource associated with
+   * this disposable is no longer needed.
+   */
+  dispose(): void;
+}
+
+/**
+ * An object that aggregates multiple {@link Disposable} instances together
+ * into a single disposable, so they can all be disposed as a group.
+ */
+export class CompositeDisposable implements DisposableLike {
+  /** Construct an instance, optionally with one or more disposables. */
+  constructor(...disposables: DisposableLike[]);
+
+  /**
+   * Dispose all disposables added to this composite disposable.
+   *
+   * If this object has already been disposed, this method has no effect.
+   */
+  dispose(): void;
+
+  // Managing Disposables
+
+  /**
+   * Add disposables to be disposed when the composite is disposed.
+   *
+   * If this object has already been disposed, this method has no effect.
+   */
+  add(...disposables: DisposableLike[]): void;
+
+  /** Remove a previously added disposable. */
+  remove(disposable: DisposableLike): void;
+
+  /** Alias of {@link remove}. */
+  delete(disposable: DisposableLike): void;
+
+  /**
+   * Clear all disposables without disposing them.
+   *
+   * They will not be disposed by the next call to {@link dispose}.
+   */
+  clear(): void;
+}
+
+/**
+ *  Utility class to be used when implementing event-based APIs that allows
+ *  for handlers registered via {@link on} to be invoked with calls to
+ *  {@link emit}.
+ */
+export class Emitter<
+  OptionalEmissions = { [key: string]: any },
+  RequiredEmissions = {}
+> implements DisposableLike {
+  /** Construct an emitter. */
+  constructor();
+
+  /** Clear out any existing subscribers. */
+  clear(): void;
+
+  /** Unsubscribe all handlers. */
+  dispose(): boolean;
+
+  // Event Subscription
+  /** Registers a handler to be invoked whenever the given event is emitted. */
+  on<T extends keyof OptionalEmissions>(
+    eventName: T,
+    handler: (value?: OptionalEmissions[T]) => void
+  ): Disposable;
+
+  /** Registers a handler to be invoked whenever the given event is emitted. */
+  on<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.
+   */
+  once<T extends keyof OptionalEmissions>(
+    eventName: T,
+    handler: (value?: OptionalEmissions[T]) => void
+  ): Disposable;
+
+  /**
+   *  Register the given handler function to be invoked the next time an event
+   *  with the given name is emitted via ::emit.
+   */
+  once<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.
+   */
+  preempt<T extends keyof OptionalEmissions>(
+    eventName: T,
+    handler: (value?: OptionalEmissions[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.
+   */
+  preempt<T extends keyof RequiredEmissions>(
+    eventName: T,
+    handler: (value: RequiredEmissions[T]) => void,
+  ): Disposable;
+
+  // Event Emission
+
+  /** Invoke the handlers registered via ::on for the given event name. */
+  emit<T extends keyof OptionalEmissions>(
+    eventName: T,
+    value?: OptionalEmissions[T]
+  ): void;
+
+  /** Invoke the handlers registered via ::on for the given event name. */
+  emit<T extends keyof RequiredEmissions>(
+    eventName: T,
+    value: RequiredEmissions[T]
+  ): void;
+}

package/dependencies/first-mate/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/first-mate";

package/dependencies/first-mate/src/first-mate.d.ts

@@ -0,0 +1 @@
+export * from "./grammar";

package/dependencies/first-mate/src/grammar.d.ts

@@ -0,0 +1,119 @@
+import { Disposable } from "../../../index";
+
+/**
+ * A class instance that encapsulates knowledge about language-specific tasks
+ * like syntax highlighting.
+ *
+ * A `Grammar` knows how translate raw text in a given language into
+ * syntax-highlighted text. The exact implementation details of how this is
+ * done may vary.
+ *
+ * The two currently supported types of grammar in Pulsar are `Grammar`
+ * (representing the original type of grammar that uses TextMate-style grammar
+ * definitions to parse code) and `WASMTreeSitterGrammar` (a newer style of
+ * grammar which uses Tree-sitter to parse code).
+ *
+ * A grammar has a human-readable name and an internal identifier that doubles
+ * as its "root" scope name. (For instance: the `name` of the JavaScript grammar
+ * is `"JavaScript"`; its `scopeName` is `"source.js"`.) You may find it useful
+ * to use the former (for text shown to the user) or the latter (for keeping
+ * track of grammar-specific concerns within your package).
+ *
+ * This object, `Grammar`, describes the original TextMate-style grammar
+ * implementation, but also serves as an abstract interface that is fulfilled
+ * by `WASMTreeSitterGrammar`. If you don't know which kind of grammar you are
+ * working with, play it safe and use only what's available on {@link Grammar};
+ * but if your package is designed to use Tree-sitter features, you may treat
+ * a grammar as a `WASMTreeSitterGrammar` once you've done type-narrowing to
+ * tell them apart. (A predicate function for telling them apart need only
+ * look at `someGrammar.constructor.name`.)
+ */
+export interface Grammar {
+  /** The name of the Grammar. */
+  readonly name: string;
+
+  /** Undocumented: scope name of the Grammar. */
+  readonly scopeName: string;
+
+  // Event Subscription
+
+  onDidUpdate(callback: () => void): Disposable;
+
+  // Tokenizing
+
+  /**
+   * Tokenize all lines in the given text.
+   *
+   * @param text A string containing one or more lines.
+   * @return An array of token arrays for each line tokenized.
+   */
+  tokenizeLines(text: string): GrammarToken[][];
+
+  /**
+   * Tokenizes the line of text.
+   *
+   * @param line A string of text to tokenize.
+   * @param ruleStack An optional array of rules previously returned from this
+   *   method. This should be null when tokenizing the first line in the file.
+   * @param firstLine A optional boolean denoting whether this is the first
+   *   line in the file which defaults to `false`.
+   * @return An object representing the result of the tokenize.
+   */
+  tokenizeLine(line: string, ruleStack?: null, firstLine?: boolean): TokenizeLineResult;
+
+  /**
+   * Tokenizes the line of text.
+   *
+   * @param line A string of text to tokenize.
+   * @param ruleStack An optional array of rules previously returned from this
+   *   method. This should be null when tokenizing the first line in the file.
+   * @param firstLine A optional boolean denoting whether this is the first
+   *   line in the file which defaults to `false`.
+   * @return An object representing the result of the tokenize.
+   */
+  tokenizeLine(line: string, ruleStack: GrammarRule[], firstLine?: false): TokenizeLineResult;
+}
+
+export interface GrammarToken {
+  value: string;
+  scopes: string[];
+}
+
+export interface GrammarRule {
+  // https://github.com/atom/first-mate/blob/v7.0.7/src/rule.coffee
+  // This is private. Don't go down the rabbit hole.
+  rule: object;
+  scopeName: string;
+  contentScopeName: string;
+}
+
+/** Result returned by `Grammar.tokenizeLine`. */
+export interface TokenizeLineResult {
+  /** The string of text that was tokenized. */
+  line: string;
+
+  /**
+   * An array of integer scope IDs and strings.
+   *
+   * Positive IDs indicate the beginning of a scope, and negative tags indicate
+   * the end.
+   *
+   * To resolve ids to scope names, call {@link GrammarRegistry#scopeForId}
+   * with the absolute value of the id.
+   */
+  tags: Array<number | string>;
+
+  /**
+   * This is a dynamic property. Invoking it will incur additional overhead,
+   * but will automatically translate the `tags` into token objects with
+   * `value` and `scopes` properties.
+   */
+  tokens: GrammarToken[];
+
+  /**
+   * An array of rules representing the tokenized state at the end of the line.
+   * These should be passed back into this method when tokenizing the next line
+   * in the file.
+   */
+  ruleStack: GrammarRule[];
+}

package/dependencies/pathwatcher/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/main";

package/dependencies/pathwatcher/src/directory.d.ts

@@ -0,0 +1,98 @@
+import { Disposable } from "../../../index";
+import { File } from "./file";
+
+/** Represents a directory on disk that can be watched for changes. */
+export class Directory {
+    // Construction
+    /** Configures a new Directory instance, no files are accessed. */
+    constructor(directoryPath: string, symlink?: boolean);
+
+    /**
+     * Creates the directory on disk that corresponds to ::getPath() if no such
+     * directory already exists.
+     */
+    create(mode?: number): Promise<boolean>;
+
+    // Event Subscription
+    /** Invoke the given callback when the directory's contents change. */
+    onDidChange(callback: () => void): Disposable;
+
+    // Directory Metadata
+    /** Returns a boolean, always false. */
+    isFile(): this is File;
+
+    /** Returns a boolean, always true. */
+    isDirectory(): this is Directory;
+
+    /** Returns a boolean indicating whether or not this is a symbolic link. */
+    isSymbolicLink(): boolean;
+
+    /**
+     * Returns a promise that resolves to a boolean, true if the directory
+     * exists, false otherwise.
+     */
+    exists(): Promise<boolean>;
+
+    /** Returns a boolean, true if the directory exists, false otherwise. */
+    existsSync(): boolean;
+
+    /**
+     * Returns a boolean: `true` if this Directory is the root directory of the
+     * filesystem, or `false` if it isn't.
+     */
+    isRoot(): boolean;
+
+    // Managing Paths
+
+    /**
+     * This may include unfollowed symlinks or relative directory entries. Or
+     * it may be fully resolved, it depends on what you give it.
+     */
+    getPath(): string;
+
+    /**
+     * All relative directory entries are removed and symlinks are resolved to
+     * their final destination.
+     */
+    getRealPathSync(): string;
+
+    /** Returns the string basename of the directory. */
+    getBaseName(): string;
+
+    /** Returns the relative string path to the given path from this directory. */
+    relativize(fullPath: string): string;
+
+    // Traversing
+    /** Traverse to the parent directory. */
+    getParent(): Directory;
+
+    /**
+     * 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.
+     */
+    getFile(filename: string): File;
+
+    /**
+     * 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.
+     */
+    getSubdirectory(dirname: string): Directory;
+
+    /** Reads file entries in this directory from disk synchronously. */
+    getEntriesSync(): Array<File | Directory>;
+
+    /** Reads file entries in this directory from disk asynchronously. */
+    getEntries(callback: (error: Error | null, entries: Array<File | Directory>) => void): void;
+
+    /**
+     * 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.
+     */
+    contains(pathToCheck: string): boolean;
+}

package/dependencies/pathwatcher/src/file.d.ts

@@ -0,0 +1,115 @@
+import { ReadStream, WriteStream } from "fs";
+import { Disposable } from "../../../index";
+import { Directory } from "./directory";
+
+/**
+ * Represents an individual file that can be watched, read from, and written to.
+ */
+export class File {
+  // Construction
+  /** Configures a new File instance, no files are accessed. */
+  constructor(filePath: string, symlink?: boolean);
+
+  /**
+   * Creates the file on disk that corresponds to {@link getPath} if no such
+   * file already exists.
+   */
+  create(): Promise<boolean>;
+
+  // Event Subscription
+  /** Invoke the given callback when the file's contents change. */
+  onDidChange(callback: () => void): Disposable;
+
+  /** Invoke the given callback when the file's path changes. */
+  onDidRename(callback: () => void): Disposable;
+
+  /** Invoke the given callback when the file is deleted. */
+  onDidDelete(callback: () => 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.
+   */
+  onWillThrowWatchError(callback: (event: PathWatchErrorThrownEvent) => void): Disposable;
+
+  // File Metadata
+  /** Returns a boolean, always true. */
+  isFile(): this is File;
+
+  /** Returns a boolean, always false. */
+  isDirectory(): this is Directory;
+
+  /** Returns a boolean indicating whether or not this is a symbolic link. */
+  isSymbolicLink(): boolean;
+
+  /**
+   * Returns a promise that resolves to a boolean — `true` if the file exists,
+   * `false` otherwise.
+   */
+  exists(): Promise<boolean>;
+
+  /** Returns a boolean, `true` if the file exists, `false` otherwise. */
+  existsSync(): boolean;
+
+  /** Get the SHA-1 digest of this file. */
+  getDigest(): Promise<string>;
+
+  /** Get the SHA-1 digest of this file. */
+  getDigestSync(): string;
+
+  /** Sets the file's character set encoding name. */
+  setEncoding(encoding: string): void;
+
+  /** Returns the string encoding name for this file (default: `"utf8"`). */
+  getEncoding(): string;
+
+  // Managing Paths
+
+  /** Returns the string path for the file. */
+  getPath(): string;
+
+  /** Returns this file's completely resolved string path. */
+  getRealPathSync(): string;
+
+  /**
+   * Returns a promise that resolves to the file's completely resolved string
+   * path.
+   */
+  getRealPath(): Promise<string>;
+
+  /** Return the string filename without any directory information. */
+  getBaseName(): string;
+
+  // Traversing
+  /** Return the Directory that contains this file. */
+  getParent(): Directory;
+
+  // Reading and Writing
+  /** Reads the contents of the file. */
+  read(flushCache?: boolean): Promise<string | null>;
+
+  /** Returns a stream to read the content of the file. */
+  createReadStream(): ReadStream;
+
+  /** Overwrites the file with the given text. */
+  write(text: string): Promise<undefined>;
+
+  /** Returns a stream to write content to the file. */
+  createWriteStream(): WriteStream;
+
+  /** Overwrites the file with the given text. */
+  writeSync(text: string): undefined;
+}
+
+export interface PathWatchErrorThrownEvent {
+  /** The error object. */
+  error: Error;
+
+  /**
+   * Call this function to indicate you have handled the error.
+   *
+   * The error will not be thrown if this function is called.
+   */
+  handle(): void;
+}

package/dependencies/pathwatcher/src/main.d.ts

@@ -0,0 +1,2 @@
+export * from "./directory";
+export * from "./file";

package/dependencies/service-hub/index.d.ts

@@ -0,0 +1,3 @@
+type Service = unknown;
+
+export * from "./src/service-hub";

package/dependencies/service-hub/src/consumer.d.ts

@@ -0,0 +1,8 @@
+import { Range } from 'semver';
+import { Service } from './util';
+
+export interface Consumer {
+  keyPath: string;
+  callback: (service: Service) => void;
+  versionRange: Range;
+}

package/dependencies/service-hub/src/provider.d.ts

@@ -0,0 +1,14 @@
+import { CompositeDisposable } from "../../event-kit";
+import { SemVer } from 'semver';
+import { Service } from './util';
+import { Consumer } from './consumer';
+
+export interface Provider  {
+  consumersDisposable: CompositeDisposable;
+  servicesByVersion: Record<string, Service | Record<string, Service>>;
+  versions: SemVer[];
+
+  provide(consumer: Consumer): void;
+
+  destroy(): void;
+}

package/dependencies/service-hub/src/service-hub.d.ts

@@ -0,0 +1,46 @@
+import { Disposable } from '../../event-kit';
+import { Consumer } from './consumer';
+import { Provider } from './provider';
+import { Service } from './util';
+
+export interface ServiceHub {
+  providers: Provider[];
+  consumers: Consumer[];
+
+  /**
+   * Provide a service by invoking the callback of all current and future
+   * consumers matching the given key path and version range, passing the
+   * provided service object to each one.
+   *
+   * @param keyPath A string of `.`-separated keys indicating the service’s
+   *   location in the namespace of all services.
+   * @param version A string containing a semantic version for the service’s
+   *   API.
+   * @param service An object exposing the service API.
+   * @returns A {@link Disposable} on which `dispose` can be called to remove
+   *   the provided service.
+   */
+  provide(keyPath: string, version: string, service: Service): Disposable;
+
+  /**
+   * Consume a service by invoking the given callback for all current and
+   * future provided services matching the given key path and range.
+   *
+   * @param keyPath A string of `.`-separated keys indicating the service’s
+   *   location in the namespace of all services.
+   * @param version A string containing a semantic version for the service’s
+   *   API.
+   * @param callback A callback that will be invoked whenever this class can
+   *   match a provider to a consumer. Takes the provider’s service object as
+   *   the sole argument.
+   * @returns A {@link Disposable} on which `dispose` can be called to remove
+   *   the consumer.
+   */
+  consume(keyPath: string, version: string, callback: (providedService: Service) => unknown): Disposable;
+
+  /**
+   * Clear out all service consumes and providers, disposing of any
+   * {@link Disposable}s returned by previous consumers.
+   */
+  clear(): void;
+}

package/dependencies/service-hub/src/util.d.ts

@@ -0,0 +1 @@
+export type Service = unknown;

package/dependencies/text-buffer/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/text-buffer";