vscode#EventEmitter TypeScript Examples

constructor(
    public readonly workspaceFolder: WorkspaceFolder,
    private readonly config: NonDisposable<ExtensionConfig>, // FIXME: get from factory
    private readonly testManager: TestManager,
    private readonly testLocator: TestLocator,
    private readonly testStore: NonDisposable<TestStore>,
    private readonly processHandler: ProcessHandler,
    private readonly testDebugger: NonDisposable<Debugger>,
    private readonly testLoadEmitter: NonDisposable<EventEmitter<TestLoadEvent>>,
    private readonly testRunEmitter: NonDisposable<EventEmitter<TestRunEvent | TestResultEvent>>,
    private readonly retireEmitter: NonDisposable<EventEmitter<RetireEvent>>,
    private readonly notificationHandler: NonDisposable<NotificationHandler>,
    private readonly logger: SimpleLogger
  ) {
    this.disposables.push(logger);
  }

constructor(
    private dbtProjectContainer: DBTProjectContainer,
    private sourceFileWatchersFactory: SourceFileWatchersFactory,
    private dbtProjectLogFactory: DBTProjectLogFactory,
    private targetWatchersFactory: TargetWatchersFactory,
    private dbtCommandFactory: DBTCommandFactory,
    private terminal: DBTTerminal,
    path: Uri,
    _onManifestChanged: EventEmitter<ManifestCacheChangedEvent>
  ) {
    this.projectRoot = path;

    const dbtProjectConfigWatcher = workspace.createFileSystemWatcher(
      new RelativePattern(path, DBTProject.DBT_PROJECT_FILE)
    );

    setupWatcherHandler(dbtProjectConfigWatcher, () => this.tryRefresh());

    this.sourceFileWatchers = this.sourceFileWatchersFactory.createSourceFileWatchers(
      this.onProjectConfigChanged
    );
    this.onSourceFileChanged = this.sourceFileWatchers.onSourceFileChanged;

    this.dbtProjectLog = this.dbtProjectLogFactory.createDBTProjectLog(
      this.onProjectConfigChanged
    );

    this.disposables.push(
      this.targetWatchersFactory.createTargetWatchers(
        _onManifestChanged,
        this.onProjectConfigChanged
      ),
      dbtProjectConfigWatcher,
      this.onSourceFileChanged(() => this.listModels()),
      this.sourceFileWatchers,
      this.dbtProjectLog
    );
  }

public constructor(
    private readonly testEventProcessor: KarmaTestEventProcessor,
    private readonly testLoadEventEmitter: EventEmitter<TestLoadEvent>,
    private readonly testRunEventEmitter: EventEmitter<TestRunEvent>,
    private readonly testResultEventEmitter: EventEmitter<TestResultEvent>,
    private readonly testRetireEventEmitter: EventEmitter<RetireEvent>,
    private readonly testDiscoveryProcessor: TestDiscoveryProcessor,
    private readonly testStore: TestStore,
    private readonly logger: Logger
  ) {
    this.disposables.push(logger);
  }

constructor(
    @inject("DBTProjectFactory")
    private dbtProjectFactory: (
      path: Uri,
      _onManifestChanged: EventEmitter<ManifestCacheChangedEvent>
    ) => DBTProject,
    workspaceFolder: WorkspaceFolder,
    _onManifestChanged: EventEmitter<ManifestCacheChangedEvent>
  ) {
    this.workspaceFolder = workspaceFolder;
    this.watcher = this.createConfigWatcher();
    this.disposables.push(this.watcher);
    this._onManifestChanged = _onManifestChanged;
  }

/**
   *
   * @param engineEvents - specifies when note state has been changed on the
   * engine
   */
  constructor(
    engineEvents: EngineEventEmitter,
    isLinkCandidateEnabled: boolean | undefined
  ) {
    this._isLinkCandidateEnabled = isLinkCandidateEnabled;

    // Set default sort order to use last updated
    this.sortOrder =
      MetadataService.instance().BacklinksPanelSortOrder ??
      BacklinkPanelSortOrder.LastUpdated;

    this._onDidChangeTreeDataEmitter = new EventEmitter<
      Backlink | undefined | void
    >();

    this.onDidChangeTreeData = this._onDidChangeTreeDataEmitter.event;
    this._engineEvents = engineEvents;
    this.setupSubscriptions();
  }

constructor(
    _onManifestChanged: EventEmitter<ManifestCacheChangedEvent>,
    onProjectConfigChanged: Event<ProjectConfigChangedEvent>,
    private manifestParser: ManifestParser
  ) {
    this._onManifestChanged = _onManifestChanged;
    this.disposables.push(
      onProjectConfigChanged((event) => this.onProjectConfigChanged(event))
    );
  }

constructor(
    public readonly workspaceFolder: WorkspaceFolder,
    private readonly projectDisplayName: string,
    portAcquisitionManager: PortAcquisitionManager,
    projectStatusDisplay: StatusDisplay,
    private readonly options?: AdapterOptions
  ) {
    let channelLog = options?.outputChannelLog;

    if (!channelLog) {
      const channelNamespaceLabel = options?.projectNamespace ? ` (${options.projectNamespace})` : '';
      channelLog = new OutputChannelLog(`${EXTENSION_OUTPUT_CHANNEL_NAME}${channelNamespaceLabel}`);
      this.disposables.push(channelLog);
    }
    this.outputChannelLog = channelLog;

    const config = this.createConfig();
    this.logger = new SimpleLogger(this.outputChannelLog, Adapter.name, config.logLevel);

    this.logger.debug(() => 'Creating port acquisition client');
    this.portAcquisitionClient = new PortAcquisitionClient(
      portAcquisitionManager,
      this.createLogger(PortAcquisitionClient.name)
    );

    this.logger.debug(() => 'Creating debugger');
    this.debugger = new Debugger(this.createLogger(Debugger.name), {
      debuggerNamespace: options?.projectNamespace ? projectDisplayName : undefined
    });
    this.disposables.push(this.debugger);

    this.logger.debug(() => 'Creating project commands handler');
    const commandsNamespace = options?.projectNamespace ? `.${options.projectNamespace}` : '';
    this.projectCommands = new Commands<ProjectCommand>(
      this.createLogger(Commands.name),
      `${EXTENSION_CONFIG_PREFIX}${commandsNamespace}`
    );
    this.projectCommands.register(ProjectCommand.ShowLog, () => this.outputChannelLog.show());
    this.projectCommands.register(ProjectCommand.Reset, () => this.reset());
    this.disposables.push(this.projectCommands);

    this.logger.debug(() => 'Creating notifications handler');
    this.notificationHandler = new NotificationHandler(
      projectStatusDisplay,
      this.createLogger(NotificationHandler.name),
      {
        showLogCommand: this.projectCommands.getCommandName(ProjectCommand.ShowLog)
      }
    );
    this.disposables.push(this.notificationHandler);

    this.logger.debug(() => 'Creating test emitters');
    this.testLoadEmitter = new EventEmitter();
    this.testRunEmitter = new EventEmitter();
    this.retireEmitter = new EventEmitter();
    this.disposables.push(this.testLoadEmitter, this.testRunEmitter, this.retireEmitter);

    const { testExplorer, testExplorerDisposables } = this.createTestExplorer(config);
    this.karmaTestExplorer = testExplorer;
    this.testExplorerDisposables = testExplorerDisposables;
  }

// This event is raised if the 'lakefile.lean' file contents is changed.
    // The event provides the lean package root Uri.
    private lakeFileChangedEmitter = new EventEmitter<Uri>();

private readonly _onConsumptionUpdateEmitter = new EventEmitter<ConsumptionEventInfo>();

_onDidChangeTreeData: EventEmitter<AbstractNode> = new EventEmitter<AbstractNode>();

private readonly _onDeleted = new EventEmitter<boolean>();

private didSetLanguageEmitter = new EventEmitter<string>();

private readonly _onDidChangeTreeData: EventEmitter<TaskTreeItem | undefined> = new EventEmitter<TaskTreeItem | undefined>();

private didChangeEmitter = new EventEmitter<Uri>();

private _onDidChangeTreeData: EventEmitter<TreeItem | null> = new EventEmitter<TreeItem | null>();

private eventEmitter: EventEmitter<Uri | Uri[]>

public constructor(
    private readonly testResultEventEmitter: EventEmitter<TestResultEvent>,
    private readonly testResolver: StoredTestResolver,
    private readonly testTreeProcessor: TestTreeProcessor,
    private readonly logger: Logger
  ) {}

private _onDidChangeTreeData: EventEmitter<CommentListEntry | undefined> = new EventEmitter<
    CommentListEntry | undefined
  >();

private readonly fileChangedEmitter = new EventEmitter();

private _onDidChangeTreeDataEmitter: EventEmitter<
    NoteProps | undefined | void
  >;

private readonly writeEmitter = new EventEmitter<string>();

function newEventQueue<T>(): EventQueue<T> {
  return {
    queue: [],
    emitter: new EventEmitter<T[]>(),
    handle: null,
  }
}

private _onDidChangeTreeData: EventEmitter<PackageTreeItem | undefined> = new EventEmitter<PackageTreeItem | undefined>();

_onDidChangeTreeData = new EventEmitter<
    UserTreeItem | RadioTreeItem | ProgramTreeItem | void
  >();

constructor(private writeEvent: EventEmitter<string>) { }

/** Helper objects to refresh UI when a new monitor is added */
    private _onDidChangeTreeData: EventEmitter<string | undefined> = new EventEmitter<string | undefined>();

private _onDidChangeTreeData: EventEmitter<HistoryTreeItem | undefined> = new EventEmitter<HistoryTreeItem | undefined>();

private progressChangedEmitter = new EventEmitter<[string, LeanFileProgressProcessingInfo[]]>()

private _emitter = new EventEmitter<FileChangeEvent[]>();