web-dev-qa-db-fra.com

Exiger nodejs "child_process" avec TypeScript, SystemJS et Electron

Je travaille sur un simple nodejs électron (anciennement appelé atom Shell) project. Je l'écris en utilisant angular 2, en utilisant le projet la même configuration de projet qu'ils recommandent dans la documentation de TypeScript:

tsc:

{
  "compilerOptions": {
    "target": "es5",
    "module": "system",
    "moduleResolution": "node",
    "sourceMap": true,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "removeComments": false,
    "noImplicitAny": false
  },
  "exclude": [
  "node_modules",
  "typings/main",
  "typings/main.d.ts"
  ]
}

J'ai besoin d'exécuter une commande, j'ai découvert que je peux le faire avec le noeud "child_process". Je n'ai pas pu trouver de toute façon pour moi "importer" ou "exiger" tout en ayant son type utilisé à partir du fichier node.d.ts. J'ai trouvé l'interface "child_process" dans le fichier node.d.ts qui convient à mes besoins, voici à quoi elle ressemble dans le fichier node.d.ts:

    declare module "child_process" {
    import * as events from "events";
    import * as stream from "stream";

    export interface ChildProcess extends events.EventEmitter {
        stdin:  stream.Writable;
        stdout: stream.Readable;
        stderr: stream.Readable;
        pid: number;
        kill(signal?: string): void;
        send(message: any, sendHandle?: any): void;
        disconnect(): void;
        unref(): void;
    }

    export function spawn(command: string, args?: string[], options?: {
        cwd?: string;
        stdio?: any;
        custom?: any;
        env?: any;
        detached?: boolean;
    }): ChildProcess;
    export function exec(command: string, options: {
        cwd?: string;
        stdio?: any;
        customFds?: any;
        env?: any;
        encoding?: string;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function exec(command: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function execFile(file: string,
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function execFile(file: string, args?: string[],
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function execFile(file: string, args?: string[], options?: {
        cwd?: string;
        stdio?: any;
        customFds?: any;
        env?: any;
        encoding?: string;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
    export function fork(modulePath: string, args?: string[], options?: {
        cwd?: string;
        env?: any;
        execPath?: string;
        execArgv?: string[];
        silent?: boolean;
        uid?: number;
        gid?: number;
    }): ChildProcess;
    export function spawnSync(command: string, args?: string[], options?: {
        cwd?: string;
        input?: string | Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }): {
        pid: number;
        output: string[];
        stdout: string | Buffer;
        stderr: string | Buffer;
        status: number;
        signal: string;
        error: Error;
    };
    export function execSync(command: string, options?: {
        cwd?: string;
        input?: string|Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }): string | Buffer;
    export function execFileSync(command: string, args?: string[], options?: {
        cwd?: string;
        input?: string|Buffer;
        stdio?: any;
        env?: any;
        uid?: number;
        gid?: number;
        timeout?: number;
        maxBuffer?: number;
        killSignal?: string;
        encoding?: string;
    }): string | Buffer;
}

mais je ne peux (comme je le sais) obtenir ce type qu'en utilisant import:

import * as child_process from 'child_process';

Le seul problème est que lorsque je fais cela, mon application ne peut pas se charger et j'obtiens l'erreur suivante dans la console:

GET file:///C:/angular2Samples/NGW-electron-VS%20-%20TEMP/child_process net::ERR_FILE_NOT_FOUND

Pour l'instant, je me déplace en utilisant:

var child_process = require('child_process');

mais je n'ai pas trouvé de toute façon pour ajouter les informations de type à ce var:

var child_process : I_CANT_PUT_ANY_CHILD_PROCESS_TYPE_HERE = require('child_process');

Des idées sur la façon dont je peux obtenir le child_process (ou tout autre module de noeud déclaré qui n'est pas une interface publique que je peux indiquer après l'opérateur ":") avec des informations de type?

Merci beaucoup à l'avance pour toute aide et explications :)

METTRE À JOUR ------------------------------------------------- -----------------

Comme les tenbits l'ont suggéré, j'ai ajouté la référence comme suit en haut du fichier: ///

et utilisé la déclaration d'importation que vous avez dit, mais n'a pas chagé mon chargeur de module. cela ne fonctionnait toujours pas avec la même erreur que prévu. Je ne me sens pas très à l'aise pour changer le système de modules, car mon projet utilise angular 2 et leurs docs et certains de leurs guides ont dit que les nouveaux projets qui n'avaient aucune préférence antérieure à ce sujet (je suis très nouveau dans la scène des chargeurs de modules et je ne comprends pas encore complètement comment cela fonctionne.) Quand j'ai essayé de le changer, j'ai eu quelques erreurs concernant angular 2 trucs dans lesquels je n'ai pas assez de temps pour entrer dans Ne devrait-il pas y avoir de moyen sans changer le chargeur de module? En jetant un coup d'œil au site systemjs, il dit au début qu'il prend en charge les modules commonjs: Systemjs doc

J'apprécierais vraiment une solution qui ne change pas le système de modules, ou peut-être une explication plus approfondie de ce qui se passe et quelles approches à ce genre de problèmes de chargement de modules existent

node.jstypescriptrequireelectronsystemjs
10
Ziv Glazer

Ok, après quelques recherches # L138 J'ai trouvé la solution

Vous pouvez utiliser import comme avant

import * as child from 'child_process';

var foo: child.ChildProcess = child.exec('foo.sh');
console.log(typeof foo.on);

Mais vous devez configurer SystemJS pour mapper le module sur NodeJS.

System.config({
  map: {
    'child_process': '@node/child_process'
  }
});

C'est tout!

24
tenbits

Pour moi, cela a fonctionné avec le rappel pour afficher les résultats.

import * as child from 'child_process';

 var foo: child.ChildProcess = child.exec('dir', (error: string, stdout: string, stderr: string) => {
            console.log(stdout);      
        });

Je n'ai ajouté aucun mappage dans SystemJS car je n'ai pas une telle configuration dans l'application de noeud

2
rinoy