Package Exports

edge-ts

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (edge-ts) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

edge-ts

Create strongly typed .NET bindings from Node.js.

In-process interop powered by the awesome edge.js.

Usage

1. Get the package

npm install --save edge-ts

2. Import it

import { sync, async, proxy } from 'edge-ts';

Types are bundled with the published package and will be automatically imported.

3. Create your bindings

interface InputArgs {
    life: string;
    universe: boolean;
    everything?: SomeOtherType;
}

const meaning = async<InputArgs, number>({
    assemblyFile: 'DeepThought.dll',
    typeName: 'FooBar.MyType',
    methodName: 'MyMethod' // This must be Func<object, Task<object>>
});

4. Call them as though they were Typscript functions

meaning({life: 'test', universe: true, everything: someOtherValue})
    .then(answer => console.log);

// some time passes

=> 42

API

Binding Targets

Bindings can be created to precompiled libraries (*.dll's) or source to be compiled at runtime by edge. Regardless of compile time, the targeted method must be of type Func<object, Task<object>>.

Source

C# source can be written in-line (as a string) as lambda expressions:

const test = async<string, string>(`
    async (input) => {
        return ".NET Welcomes " + input.ToString();
    }
`);

As full classes:

const test = async<string, string>(`
    using System.Data;
    using System.Threading.Tasks;

    public class Startup
    {
        public async Task<object> Invoke(object input)
        {
            // ...
        }
    }
`);

Or referenced as an external file:

const test = async<string, string>({
    source: 'Foo.cs',
    typeName: 'MyType',             // optional, defaults to 'StartUp'
    methodName: 'MyMethod',         // optional, defaults to 'Invoke'
    references: ['MyOtherLib.dll'], // optional (any external assemblies required)
});

Precompiled

Precompiled targets take a similar form:

const test = async<string, string>({
    assemblyFile: 'MyAssembly.dll',
    typeName: 'MyType',             // optional, defaults to 'StartUp'
    methodName: 'MyMethod',         // optional, defaults to 'Invoke'
    references: ['MyOtherLib.dll'], // optional (any external assemblies required)
});

Or, if you're happy with the defaults, just the path to the assembly:

const test = async<string, string>('MyAssembly.dll');

`async<I, O>(«binding target»)`

Create an asynchronous function, bound to a CLR/.NET Core/Mono method.

The returned function accepts an input (of type I) and returns a Promise (of type O).

Alternatively a Node style callback may be passed as a second argument.

const myAsyncBinding = async<number, string>('FooBar.dll');

myAsyncBinding(123)
    .then(doSomething);
    .catch(e => console.log('Oh noes!!!'));

// or

myAsyncBinding(123, (err, result) => {
    if (err) {
        console.log('Oh noes!!!');
    } else {
        doSomething(result);
    }
});

`sync<I, O>(«binding target»)`

Creates a synchronous function, bound to a CLR/.NET Core/Mono method.

The returned function takes a single input argument (or type I) and returns an output of type O. If the linked method does not return a synchronous result, an Error will be raised.

const mySyncBinding = sync<number, string>('FooBar.dll');

doSomthing(mySyncBinding(123));

`proxy<I, O>(«func»)`

Functions may also be passed to the CLR to allow it to call back into Node. These must be of a specific form expected by edge. proxy(..) may be used to transform a function of type I => O into this form.

For further information on marshaling data between the environments, refer to the edge.js guide