@theia/process 1.48.1 → 1.48.3

package/lib/node/process-backend-module.d.ts

@@ -1,4 +1,4 @@
-import { ContainerModule } from '@theia/core/shared/inversify';
-declare const _default: ContainerModule;
-export default _default;
+import { ContainerModule } from '@theia/core/shared/inversify';
+declare const _default: ContainerModule;
+export default _default;
 //# sourceMappingURL=process-backend-module.d.ts.map

package/lib/node/process-backend-module.js

@@ -1,57 +1,57 @@
-"use strict";
-// *****************************************************************************
-// Copyright (C) 2017 Ericsson and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-Object.defineProperty(exports, "__esModule", { value: true });
-const inversify_1 = require("@theia/core/shared/inversify");
-const raw_process_1 = require("./raw-process");
-const terminal_process_1 = require("./terminal-process");
-const task_terminal_process_1 = require("./task-terminal-process");
-const node_1 = require("@theia/core/lib/node");
-const process_manager_1 = require("./process-manager");
-const common_1 = require("@theia/core/lib/common");
-const multi_ring_buffer_1 = require("./multi-ring-buffer");
-exports.default = new inversify_1.ContainerModule(bind => {
-    bind(raw_process_1.RawProcess).toSelf().inTransientScope();
-    bind(process_manager_1.ProcessManager).toSelf().inSingletonScope();
-    bind(node_1.BackendApplicationContribution).toService(process_manager_1.ProcessManager);
-    bind(common_1.ILogger).toDynamicValue(ctx => {
-        const parentLogger = ctx.container.get(common_1.ILogger);
-        return parentLogger.child('process');
-    }).inSingletonScope().whenTargetNamed('process');
-    bind(raw_process_1.RawProcessFactory).toFactory(ctx => (options) => {
-        const child = new inversify_1.Container({ defaultScope: 'Singleton' });
-        child.parent = ctx.container;
-        child.bind(raw_process_1.RawProcessOptions).toConstantValue(options);
-        return child.get(raw_process_1.RawProcess);
-    });
-    bind(terminal_process_1.TerminalProcess).toSelf().inTransientScope();
-    bind(terminal_process_1.TerminalProcessFactory).toFactory(ctx => (options) => {
-        const child = new inversify_1.Container({ defaultScope: 'Singleton' });
-        child.parent = ctx.container;
-        child.bind(terminal_process_1.TerminalProcessOptions).toConstantValue(options);
-        return child.get(terminal_process_1.TerminalProcess);
-    });
-    bind(task_terminal_process_1.TaskTerminalProcess).toSelf().inTransientScope();
-    bind(task_terminal_process_1.TaskTerminalProcessFactory).toFactory(ctx => (options) => {
-        const child = ctx.container.createChild();
-        child.bind(terminal_process_1.TerminalProcessOptions).toConstantValue(options);
-        return child.get(task_terminal_process_1.TaskTerminalProcess);
-    });
-    bind(multi_ring_buffer_1.MultiRingBuffer).toSelf().inTransientScope();
-    /* 1MB size, TODO should be a user preference. */
-    bind(multi_ring_buffer_1.MultiRingBufferOptions).toConstantValue({ size: 1048576 });
-});
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2017 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+const inversify_1 = require("@theia/core/shared/inversify");
+const raw_process_1 = require("./raw-process");
+const terminal_process_1 = require("./terminal-process");
+const task_terminal_process_1 = require("./task-terminal-process");
+const node_1 = require("@theia/core/lib/node");
+const process_manager_1 = require("./process-manager");
+const common_1 = require("@theia/core/lib/common");
+const multi_ring_buffer_1 = require("./multi-ring-buffer");
+exports.default = new inversify_1.ContainerModule(bind => {
+    bind(raw_process_1.RawProcess).toSelf().inTransientScope();
+    bind(process_manager_1.ProcessManager).toSelf().inSingletonScope();
+    bind(node_1.BackendApplicationContribution).toService(process_manager_1.ProcessManager);
+    bind(common_1.ILogger).toDynamicValue(ctx => {
+        const parentLogger = ctx.container.get(common_1.ILogger);
+        return parentLogger.child('process');
+    }).inSingletonScope().whenTargetNamed('process');
+    bind(raw_process_1.RawProcessFactory).toFactory(ctx => (options) => {
+        const child = new inversify_1.Container({ defaultScope: 'Singleton' });
+        child.parent = ctx.container;
+        child.bind(raw_process_1.RawProcessOptions).toConstantValue(options);
+        return child.get(raw_process_1.RawProcess);
+    });
+    bind(terminal_process_1.TerminalProcess).toSelf().inTransientScope();
+    bind(terminal_process_1.TerminalProcessFactory).toFactory(ctx => (options) => {
+        const child = new inversify_1.Container({ defaultScope: 'Singleton' });
+        child.parent = ctx.container;
+        child.bind(terminal_process_1.TerminalProcessOptions).toConstantValue(options);
+        return child.get(terminal_process_1.TerminalProcess);
+    });
+    bind(task_terminal_process_1.TaskTerminalProcess).toSelf().inTransientScope();
+    bind(task_terminal_process_1.TaskTerminalProcessFactory).toFactory(ctx => (options) => {
+        const child = ctx.container.createChild();
+        child.bind(terminal_process_1.TerminalProcessOptions).toConstantValue(options);
+        return child.get(task_terminal_process_1.TaskTerminalProcess);
+    });
+    bind(multi_ring_buffer_1.MultiRingBuffer).toSelf().inTransientScope();
+    /* 1MB size, TODO should be a user preference. */
+    bind(multi_ring_buffer_1.MultiRingBufferOptions).toConstantValue({ size: 1048576 });
+});
 //# sourceMappingURL=process-backend-module.js.map

package/lib/node/process-manager.d.ts

@@ -1,34 +1,34 @@
-import { Emitter, Event } from '@theia/core/lib/common';
-import { ILogger } from '@theia/core/lib/common/logger';
-import { BackendApplicationContribution } from '@theia/core/lib/node';
-import { ManagedProcessManager, ManagedProcess } from '../common/process-manager-types';
-import { Process } from './process';
-export declare class ProcessManager implements ManagedProcessManager, BackendApplicationContribution {
-    protected logger: ILogger;
-    protected readonly processes: Map<number, Process>;
-    protected readonly deleteEmitter: Emitter<number>;
-    constructor(logger: ILogger);
-    /**
-     * Registers the given process into this manager. Both on process termination and on error,
-     * the process will be automatically removed from the manager.
-     *
-     * @param process the process to register.
-     */
-    register(process: Process): number;
-    /**
-     * @returns a random id for a process that is not assigned to a different process yet.
-     */
-    protected generateId(): number;
-    /**
-     * Removes the process from this process manager. Invoking this method, will make
-     * sure that the process is terminated before eliminating it from the manager's cache.
-     *
-     * @param process the process to unregister from this process manager.
-     */
-    unregister(process: ManagedProcess): void;
-    get(id: number): ManagedProcess | undefined;
-    get onDelete(): Event<number>;
-    onStop(): void;
-    private getProcessLabel;
-}
+import { Emitter, Event } from '@theia/core/lib/common';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { BackendApplicationContribution } from '@theia/core/lib/node';
+import { ManagedProcessManager, ManagedProcess } from '../common/process-manager-types';
+import { Process } from './process';
+export declare class ProcessManager implements ManagedProcessManager, BackendApplicationContribution {
+    protected logger: ILogger;
+    protected readonly processes: Map<number, Process>;
+    protected readonly deleteEmitter: Emitter<number>;
+    constructor(logger: ILogger);
+    /**
+     * Registers the given process into this manager. Both on process termination and on error,
+     * the process will be automatically removed from the manager.
+     *
+     * @param process the process to register.
+     */
+    register(process: Process): number;
+    /**
+     * @returns a random id for a process that is not assigned to a different process yet.
+     */
+    protected generateId(): number;
+    /**
+     * Removes the process from this process manager. Invoking this method, will make
+     * sure that the process is terminated before eliminating it from the manager's cache.
+     *
+     * @param process the process to unregister from this process manager.
+     */
+    unregister(process: ManagedProcess): void;
+    get(id: number): ManagedProcess | undefined;
+    get onDelete(): Event<number>;
+    onStop(): void;
+    private getProcessLabel;
+}
 //# sourceMappingURL=process-manager.d.ts.map

package/lib/node/process-manager.js

@@ -1,103 +1,103 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessManager = void 0;
-const tslib_1 = require("tslib");
-// *****************************************************************************
-// Copyright (C) 2017 Ericsson and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-const inversify_1 = require("@theia/core/shared/inversify");
-const common_1 = require("@theia/core/lib/common");
-const logger_1 = require("@theia/core/lib/common/logger");
-const numbers_1 = require("@theia/core/lib/common/numbers");
-let ProcessManager = class ProcessManager {
-    constructor(logger) {
-        this.logger = logger;
-        this.processes = new Map();
-        this.deleteEmitter = new common_1.Emitter();
-    }
-    /**
-     * Registers the given process into this manager. Both on process termination and on error,
-     * the process will be automatically removed from the manager.
-     *
-     * @param process the process to register.
-     */
-    register(process) {
-        const id = this.generateId();
-        this.processes.set(id, process);
-        process.onError(() => this.unregister(process));
-        return id;
-    }
-    /**
-     * @returns a random id for a process that is not assigned to a different process yet.
-     */
-    generateId() {
-        let id = undefined;
-        while (id === undefined) {
-            const candidate = Math.floor(Math.random() * numbers_1.MAX_SAFE_INTEGER);
-            if (!this.processes.has(candidate)) {
-                id = candidate;
-            }
-        }
-        return id;
-    }
-    /**
-     * Removes the process from this process manager. Invoking this method, will make
-     * sure that the process is terminated before eliminating it from the manager's cache.
-     *
-     * @param process the process to unregister from this process manager.
-     */
-    unregister(process) {
-        const processLabel = this.getProcessLabel(process);
-        this.logger.debug(`Unregistering process. ${processLabel}`);
-        if (!process.killed) {
-            this.logger.debug(`Ensuring process termination. ${processLabel}`);
-            process.kill();
-        }
-        if (this.processes.delete(process.id)) {
-            this.deleteEmitter.fire(process.id);
-            this.logger.debug(`The process was successfully unregistered. ${processLabel}`);
-        }
-        else {
-            this.logger.warn(`This process was not registered or was already unregistered. ${processLabel}`);
-        }
-    }
-    get(id) {
-        return this.processes.get(id);
-    }
-    get onDelete() {
-        return this.deleteEmitter.event;
-    }
-    onStop() {
-        for (const process of this.processes.values()) {
-            try {
-                this.unregister(process);
-            }
-            catch (error) {
-                this.logger.error(`Error occurred when unregistering process. ${this.getProcessLabel(process)}`, error);
-            }
-        }
-    }
-    getProcessLabel(process) {
-        return `[ID: ${process.id}]`;
-    }
-};
-ProcessManager = (0, tslib_1.__decorate)([
-    (0, inversify_1.injectable)(),
-    (0, tslib_1.__param)(0, (0, inversify_1.inject)(logger_1.ILogger)),
-    (0, tslib_1.__param)(0, (0, inversify_1.named)('process')),
-    (0, tslib_1.__metadata)("design:paramtypes", [Object])
-], ProcessManager);
-exports.ProcessManager = ProcessManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessManager = void 0;
+const tslib_1 = require("tslib");
+// *****************************************************************************
+// Copyright (C) 2017 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+const inversify_1 = require("@theia/core/shared/inversify");
+const common_1 = require("@theia/core/lib/common");
+const logger_1 = require("@theia/core/lib/common/logger");
+const numbers_1 = require("@theia/core/lib/common/numbers");
+let ProcessManager = class ProcessManager {
+    constructor(logger) {
+        this.logger = logger;
+        this.processes = new Map();
+        this.deleteEmitter = new common_1.Emitter();
+    }
+    /**
+     * Registers the given process into this manager. Both on process termination and on error,
+     * the process will be automatically removed from the manager.
+     *
+     * @param process the process to register.
+     */
+    register(process) {
+        const id = this.generateId();
+        this.processes.set(id, process);
+        process.onError(() => this.unregister(process));
+        return id;
+    }
+    /**
+     * @returns a random id for a process that is not assigned to a different process yet.
+     */
+    generateId() {
+        let id = undefined;
+        while (id === undefined) {
+            const candidate = Math.floor(Math.random() * numbers_1.MAX_SAFE_INTEGER);
+            if (!this.processes.has(candidate)) {
+                id = candidate;
+            }
+        }
+        return id;
+    }
+    /**
+     * Removes the process from this process manager. Invoking this method, will make
+     * sure that the process is terminated before eliminating it from the manager's cache.
+     *
+     * @param process the process to unregister from this process manager.
+     */
+    unregister(process) {
+        const processLabel = this.getProcessLabel(process);
+        this.logger.debug(`Unregistering process. ${processLabel}`);
+        if (!process.killed) {
+            this.logger.debug(`Ensuring process termination. ${processLabel}`);
+            process.kill();
+        }
+        if (this.processes.delete(process.id)) {
+            this.deleteEmitter.fire(process.id);
+            this.logger.debug(`The process was successfully unregistered. ${processLabel}`);
+        }
+        else {
+            this.logger.warn(`This process was not registered or was already unregistered. ${processLabel}`);
+        }
+    }
+    get(id) {
+        return this.processes.get(id);
+    }
+    get onDelete() {
+        return this.deleteEmitter.event;
+    }
+    onStop() {
+        for (const process of this.processes.values()) {
+            try {
+                this.unregister(process);
+            }
+            catch (error) {
+                this.logger.error(`Error occurred when unregistering process. ${this.getProcessLabel(process)}`, error);
+            }
+        }
+    }
+    getProcessLabel(process) {
+        return `[ID: ${process.id}]`;
+    }
+};
+ProcessManager = (0, tslib_1.__decorate)([
+    (0, inversify_1.injectable)(),
+    (0, tslib_1.__param)(0, (0, inversify_1.inject)(logger_1.ILogger)),
+    (0, tslib_1.__param)(0, (0, inversify_1.named)('process')),
+    (0, tslib_1.__metadata)("design:paramtypes", [Object])
+], ProcessManager);
+exports.ProcessManager = ProcessManager;
 //# sourceMappingURL=process-manager.js.map

package/lib/node/process.d.ts

@@ -1,96 +1,96 @@
-/// <reference types="node" />
-import { ILogger, Emitter, Event } from '@theia/core/lib/common';
-import { Readable, Writable } from 'stream';
-import { IProcessStartEvent, IProcessExitEvent, ProcessErrorEvent, ProcessType, ManagedProcessManager, ManagedProcess } from '../common/process-manager-types';
-export { IProcessStartEvent, IProcessExitEvent, ProcessErrorEvent, ProcessType };
-/**
- * Options to spawn a new process (`spawn`).
- *
- * For more information please refer to the spawn function of Node's
- * child_process module:
- *
- *   https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options
- */
-export interface ProcessOptions {
-    readonly command: string;
-    args?: string[];
-    options?: {
-        [key: string]: any;
-    };
-}
-/**
- * Options to fork a new process using the current Node interpreter (`fork`).
- *
- * For more information please refer to the fork function of Node's
- * child_process module:
- *
- *   https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options
- */
-export interface ForkOptions {
-    readonly modulePath: string;
-    args?: string[];
-    options?: object;
-}
-export declare abstract class Process implements ManagedProcess {
-    protected readonly processManager: ManagedProcessManager;
-    protected readonly logger: ILogger;
-    protected readonly type: ProcessType;
-    protected readonly options: ProcessOptions | ForkOptions;
-    readonly id: number;
-    protected readonly startEmitter: Emitter<IProcessStartEvent>;
-    protected readonly exitEmitter: Emitter<IProcessExitEvent>;
-    protected readonly closeEmitter: Emitter<IProcessExitEvent>;
-    protected readonly errorEmitter: Emitter<ProcessErrorEvent>;
-    protected _killed: boolean;
-    /**
-     * The OS process id.
-     */
-    abstract readonly pid: number;
-    /**
-     * The stdout stream.
-     */
-    abstract readonly outputStream: Readable;
-    /**
-     * The stderr stream.
-     */
-    abstract readonly errorStream: Readable;
-    /**
-     * The stdin stream.
-     */
-    abstract readonly inputStream: Writable;
-    constructor(processManager: ManagedProcessManager, logger: ILogger, type: ProcessType, options: ProcessOptions | ForkOptions);
-    abstract kill(signal?: string): void;
-    get killed(): boolean;
-    get onStart(): Event<IProcessStartEvent>;
-    /**
-     * Wait for the process to exit, streams can still emit data.
-     */
-    get onExit(): Event<IProcessExitEvent>;
-    get onError(): Event<ProcessErrorEvent>;
-    /**
-     * Waits for both process exit and for all the streams to be closed.
-     */
-    get onClose(): Event<IProcessExitEvent>;
-    protected emitOnStarted(): void;
-    /**
-     * Emit the onExit event for this process.  Only one of code and signal
-     * should be defined.
-     */
-    protected emitOnExit(code?: number, signal?: string): void;
-    /**
-     * Emit the onClose event for this process.  Only one of code and signal
-     * should be defined.
-     */
-    protected emitOnClose(code?: number, signal?: string): void;
-    protected handleOnExit(event: IProcessExitEvent): void;
-    protected emitOnError(err: ProcessErrorEvent): void;
-    protected emitOnErrorAsync(error: ProcessErrorEvent): Promise<void>;
-    protected handleOnError(error: ProcessErrorEvent): void;
-    protected isForkOptions(options: unknown): options is ForkOptions;
-    protected readonly initialCwd: string;
-    /**
-     * @returns the current working directory as a URI (usually file:// URI)
-     */
-    getCwdURI(): Promise<string>;
-}
+/// <reference types="node" />
+import { ILogger, Emitter, Event } from '@theia/core/lib/common';
+import { Readable, Writable } from 'stream';
+import { IProcessStartEvent, IProcessExitEvent, ProcessErrorEvent, ProcessType, ManagedProcessManager, ManagedProcess } from '../common/process-manager-types';
+export { IProcessStartEvent, IProcessExitEvent, ProcessErrorEvent, ProcessType };
+/**
+ * Options to spawn a new process (`spawn`).
+ *
+ * For more information please refer to the spawn function of Node's
+ * child_process module:
+ *
+ *   https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options
+ */
+export interface ProcessOptions {
+    readonly command: string;
+    args?: string[];
+    options?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Options to fork a new process using the current Node interpreter (`fork`).
+ *
+ * For more information please refer to the fork function of Node's
+ * child_process module:
+ *
+ *   https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options
+ */
+export interface ForkOptions {
+    readonly modulePath: string;
+    args?: string[];
+    options?: object;
+}
+export declare abstract class Process implements ManagedProcess {
+    protected readonly processManager: ManagedProcessManager;
+    protected readonly logger: ILogger;
+    protected readonly type: ProcessType;
+    protected readonly options: ProcessOptions | ForkOptions;
+    readonly id: number;
+    protected readonly startEmitter: Emitter<IProcessStartEvent>;
+    protected readonly exitEmitter: Emitter<IProcessExitEvent>;
+    protected readonly closeEmitter: Emitter<IProcessExitEvent>;
+    protected readonly errorEmitter: Emitter<ProcessErrorEvent>;
+    protected _killed: boolean;
+    /**
+     * The OS process id.
+     */
+    abstract readonly pid: number;
+    /**
+     * The stdout stream.
+     */
+    abstract readonly outputStream: Readable;
+    /**
+     * The stderr stream.
+     */
+    abstract readonly errorStream: Readable;
+    /**
+     * The stdin stream.
+     */
+    abstract readonly inputStream: Writable;
+    constructor(processManager: ManagedProcessManager, logger: ILogger, type: ProcessType, options: ProcessOptions | ForkOptions);
+    abstract kill(signal?: string): void;
+    get killed(): boolean;
+    get onStart(): Event<IProcessStartEvent>;
+    /**
+     * Wait for the process to exit, streams can still emit data.
+     */
+    get onExit(): Event<IProcessExitEvent>;
+    get onError(): Event<ProcessErrorEvent>;
+    /**
+     * Waits for both process exit and for all the streams to be closed.
+     */
+    get onClose(): Event<IProcessExitEvent>;
+    protected emitOnStarted(): void;
+    /**
+     * Emit the onExit event for this process.  Only one of code and signal
+     * should be defined.
+     */
+    protected emitOnExit(code?: number, signal?: string): void;
+    /**
+     * Emit the onClose event for this process.  Only one of code and signal
+     * should be defined.
+     */
+    protected emitOnClose(code?: number, signal?: string): void;
+    protected handleOnExit(event: IProcessExitEvent): void;
+    protected emitOnError(err: ProcessErrorEvent): void;
+    protected emitOnErrorAsync(error: ProcessErrorEvent): Promise<void>;
+    protected handleOnError(error: ProcessErrorEvent): void;
+    protected isForkOptions(options: unknown): options is ForkOptions;
+    protected readonly initialCwd: string;
+    /**
+     * @returns the current working directory as a URI (usually file:// URI)
+     */
+    getCwdURI(): Promise<string>;
+}
 //# sourceMappingURL=process.d.ts.map