Ich arbeite an einem einfachen nodejsElektro (früher bekannt als Atom Shell) Projekt. Ich schreibe es mit Winkel 2 und verwende das Projekt mit dem gleichen Projektaufbau, wie er in der Dokumentation für Typoskript empfohlen wird:

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"
  ]
}

Ich muss einen Befehl ausführen, ich habe herausgefunden, dass ich das mit dem Knoten "child_process" machen kann. Ich konnte es ohnehin nicht finden, dass ich es "importiere" oder "benötige", während sein Typ aus der Datei node.d.ts verwendet wird. Ich habe die Schnittstelle "child_process" in der Datei node.d.ts gefunden, die meinen Anforderungen entspricht. So sieht es in der Datei node.d.ts aus:

    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;
}

, aber ich kann diesen Typ (wie ich weiß) nur mit import erhalten:

import * as child_process from 'child_process'; 

Nur das Problem ist, dass meine App dabei nicht geladen werden kann und die folgende Fehlermeldung in der Konsole angezeigt wird:

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

For now, im herumkommen mit:

var child_process = require('child_process');

aber ich konnte trotzdem keine Typinformationen zu dieser Var finden:

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

Haben Sie eine Idee, wie ich den child_process (oder andere deklarierte Knotenmodule, die keine öffentliche Schnittstelle sind, die ich nach dem Operator ":" angeben kann) mit Typinformationen erhalten kann?

Vielen Dank im Voraus für jede Hilfe und Erklärungen:)

UPDATE ------------------------------------------------ ------------------

Wie von Tenbits vorgeschlagen, habe ich den Verweis wie folgt am Anfang der Datei hinzugefügt: ///

und habe die Import-Anweisung verwendet, die Sie angegeben haben, aber meinen Modul-Loader nicht geändert. Es funktionierte immer noch nicht mit dem gleichen Fehler wie erwartet. Ich fühle mich nicht sehr wohl, wenn ich das Modulsystem ändere, da mein Projekt Angle 2 und deren Dokumente verwendet und einige ihrer Leitfäden sagten, dass neue Projekte keine Vorliebe für diese Angelegenheit haben (ich bin sehr neu in der Modulladerszene und ich bin nicht vollständig verstehen, wie es noch funktioniert). Als ich versuchte, es zu ändern, bekam ich einige Fehler in Bezug auf eckige 2 Sachen, für die ich im Moment nicht genug Zeit habe. Sollte es keinen Weg dazu geben, ohne den Modullader zu wechseln? Wenn Sie einen Blick auf die systemjs-Site werfen, heißt es am Anfang, dass es commonjs-Module unterstützt:Systemjs doc

Ich würde wirklich eine Lösung schätzen, die das Modulsystem nicht verändert, oder vielleicht eine ausführlichere Erklärung darüber, was los ist und welche Ansätze für solche Probleme beim Laden von Modulen es gibt.