vscode#Disposable TypeScript Examples

class CodeLensController implements Disposable {
    private internalProvider: CustomCodeLensProvider;
    private registeredProvider: Disposable | undefined;

    constructor() {
        this.internalProvider = new CustomCodeLensProvider();

        this.registeredProvider = languages.registerCodeLensProvider(
            { scheme: 'file' },
            this.internalProvider,
        );
    }

    public dispose(): void {
        if (this.registeredProvider) {
            this.registeredProvider.dispose();
        }
    }
}

public init(): Disposable[] {
        if (this.isInit) return []
        const res: Disposable[] = []
        this.provider = new ConnectionProvider(this.context)
        const treeview = vscode.window.createTreeView("github.cweijan.ssh", {
            treeDataProvider: this.provider
        });
        res.push(treeview)
        this.isInit = true
        return res
    }

/**
 * Configures string split capability for the extension.
 */
export class StringSplitFeature implements Disposable {

    private disposables: Disposable[] = [];
    private provider: StringSplitter;
    private ballerinaExtInstance: BallerinaExtension;

    constructor(provider: StringSplitter, ballerinaExtInstance: BallerinaExtension) {
        this.provider = provider;
        this.ballerinaExtInstance = ballerinaExtInstance;
        workspace.onDidChangeTextDocument(this.provider.updateDocument, this.ballerinaExtInstance, this.disposables);
    }

    dispose() {
        this.disposables.forEach((disposable) => disposable.dispose());
    }
}

watch(uri: Uri, options: { recursive: boolean; excludes: string[] }): Disposable {
    const path = fromUtopiaURI(uri)
    watch(
      path,
      options.recursive,
      this.notifyFileCreated.bind(this),
      this.notifyFileChanged.bind(this),
      this.notifyFileDeleted.bind(this),
      () => {
        /* no op */
      },
    )

    return new Disposable(() => {
      stopWatching(path, options.recursive)
    })
  }

private async getLanguageServerVersionAfterStartup(): Promise<string> {
    let versionRegistration: Disposable | undefined;
    const version = await PromiseAny([
      new Promise<string>(resolve => {
        versionRegistration = this.client!.onServerVersion(version => resolve(version));
      }),
      // Fallback to unknown in case the server does not report the version.
      timeout(DafnyVersionTimeoutMs, LanguageServerConstants.UnknownVersion)
    ]);
    versionRegistration!.dispose();
    return version;
  }

/**
 * 注册一个 vscode 的命令，封装日志相关的处理
 * @param command
 * @param callback
 * @param thisArg
 */
export function registerCommand(command: string, callback: (...args: any[]) => any, thisArg?: any): Disposable {
  return vscode.commands.registerCommand(
    command,
    async (...args: any[]) => {
      try {
        return await callback(...args)
      } catch (err) {
        logger.error('command error: ', command, err)
        throw err
      }
    },
    thisArg,
  )
}

/**
 * Registers the `microprofile.command.open.uri` command.
 * This command gives the capability to open the given uri of the command.
 */
export function registerOpenURICommand(): Disposable {
  return commands.registerCommand(CommandKind.COMMAND_OPEN_URI, (uri) => {
    commands.executeCommand('vscode.open', Uri.parse(uri));
  });
}

export class TempFolder implements Disposable {
    folder : string;

    constructor(prefix: string){
        this.folder = fs.mkdtempSync(join(os.tmpdir(), prefix))
    }

    createFile(fileName : string, data : string) : string {
        const path = join(this.folder, fileName)
        fs.writeFileSync(path, data, { encoding: 'utf8'});
        return path;
    }

    dispose(): void {
        if (this.folder){
            try {
                fs.rmdirSync(this.folder, {
                    recursive: true
                })
            } catch {}
        }
    }
}

/**
   * A view or a controller can bind a callback to the viewmodel with this
   * function
   * @param callback
   * @param thisArg
   * @returns
   */
  bind(
    callback: (newValue: T, previous: T) => void,
    thisArg?: any
  ): Disposable {
    return this._emitter.event((data) => {
      const bound = callback.bind(thisArg);
      bound(data.newValue, data.previous);
    });
  }

/**
 * Like `autorun`, but more suited for working with Disposables.
 * The `disposables` passed to `reaction` will be disposed when the reaction is triggered again.
 */
export function autorunDisposable(
	reaction: (disposables: Disposable[]) => void
): Disposable {
	let lastDisposable = new Array<Disposable>();
	return {
		dispose: autorun(() => {
			for (const d of lastDisposable) {
				d.dispose();
			}
			lastDisposable = [];
			reaction(lastDisposable);
		}),
	};
}

export function registerFailableCommand(
	commandName: string,
	commandFn: (...args: any[]) => any
): Disposable {
	return commands.registerCommand(commandName, async (...args: any[]) => {
		try {
			return await commandFn(...args);
		} catch (e) {
			window.showErrorMessage("The command failed: " + e.message);
			return false;
		}
	});
}

@provideSingleton(AutocompletionProviders)
export class AutocompletionProviders implements Disposable {
  private disposables: Disposable[] = [];
  constructor(
    private macroAutocompletionProvider: MacroAutocompletionProvider,
    private modelAutocompletionProvider: ModelAutocompletionProvider,
    private sourceAutocompletionProvider: SourceAutocompletionProvider
  ) {
    this.disposables.push(
      languages.registerCompletionItemProvider(
        DBTPowerUserExtension.DBT_MODE,
        this.macroAutocompletionProvider
      ),
      languages.registerCompletionItemProvider(
        DBTPowerUserExtension.DBT_MODE,
        this.modelAutocompletionProvider,
        "'",
        '"'
      ),
      languages.registerCompletionItemProvider(
        DBTPowerUserExtension.DBT_MODE,
        this.sourceAutocompletionProvider,
        "'",
        '"'
      ),
    );
  }

  dispose() {
    this.disposables.forEach(disposable => disposable.dispose());
  }
}

/**
     * DoComment constructor
     */
    constructor() {       
        const subscriptions: Disposable[] = [];

        workspace.onDidChangeTextDocument(event => {            
            const activeEditor = window.activeTextEditor;

            if (event.document.languageId !== 'al') {
                return;
            }

            if (activeEditor && event.document === activeEditor.document) {
                this.DoComment(activeEditor, event.contentChanges[0]);
            }
        }, this, subscriptions);
        
        this.disposable = Disposable.from(...subscriptions);
    }

private disposables: Disposable[] = [];

private registeredProvider: Disposable | undefined;

private disposables: Disposable[] = [];

private readonly _edited: Disposable;

static changeActiveTextEditorDisposable: Disposable;

private subscriptions: Disposable[] = [];

public activate(subscriptions: Disposable[]) {
		let provider = new LintingProvider(this);
		provider.activate(subscriptions);
	}

taskProvider: Disposable | undefined

private disposables: Disposable[] = [];

/**
 * Registers the `CommandKind.COMMAND_REFERENCES` command
 */
export function registerReferencesCommand(): Disposable {
  return commands.registerCommand(CommandKind.COMMAND_REFERENCES, () => {
    // not yet implemented
  });
}

private subscriptions: Disposable[] = [];

private _disposables: Disposable[] = [];

private disposables: Disposable[] = [];

_textDocumentEventHandle: Disposable;

private setReviewFileSelectedCsvRegistration!: Disposable;

private _onDidChangeActiveTextEditorDisposable: Disposable | undefined;