> For the complete documentation index, see [llms.txt](https://stefansarya.gitbook.io/blackprint/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://stefansarya.gitbook.io/blackprint/engine/getting-started.md).

# Register Node

## Node?

* This is where we define our node structure like input/output/properties, title, and description
* Can be ported easily on different programming languages
  * That's mean we can't call specific language's API
  * Any interaction with specific language's API like input/output must be registered on Interface.
  * This supposed to run on NodeJS too, so don't control any HTML element directly inside this.
  * Don't declare or use variable outside of function context/scope.
* Just think you want to create a compatible logic to be ported on Browser/Node.js/PHP/Python.
* Just let this `node` control and communicate with your registered `interface`.

```javascript
// Register a new node
// -> (namespace, callback)
Blackprint.registerNode('math/multiply', function(node, iface){
    // node = Blackprint flow handler
    // iface = ScarletsFrame element handler

    // Give it a title
    iface.title = "Random";

    // Give it a description
    iface.description = "Multiply something";

    // If the node would have value that can be exported to JSON
    // It must being set inside options object
    iface.options = {};

    //> We will use `default` node type, so let this empty or undefined
    // iface.interface = 'bp/default';

    // ... Other information below ...
});
```

#### Reserved handler property

`node` here is the Blackprint flow handler from the example above.

| Property   | Description                                                  |
| ---------- | ------------------------------------------------------------ |
| inputs     | An array of input port registration                          |
| outputs    | An array of output port registration                         |
| properties | An array of node property registration `Still draft feature` |
| importing  | A boolean indicating if this node is being imported/created  |

Below are reserved property that filled with function/callback

| Property | Arguments                  | Description                                                                        |
| -------- | -------------------------- | ---------------------------------------------------------------------------------- |
| init     | `()`                       | Callback function to be run after current handle and all node was initialized      |
| request  | `(targetPort, sourceNode)` | Callback when other node's input port are requesting current node's output value   |
| update   | `(Cable)`                  | Callback when current input value are updated from the other node's output port    |
| imported | `(options)`                | This is a callback after node was created, imported options should be handled here |

For the detailed example you can see from [this repository](https://github.com/Blackprint/blackprint.github.io/blob/master/src/js/register-handler.js).

### Node port registration

The port must be registered on the `node` and Blackprint will create internal control with ScarletsFrame so the port can being used for sending or obtaining data from other node's port.

```javascript
// ========= Port Format ==========
// ... = { PortName: DataType }

// Output port
node.outputs = {
    // Declare Result as a output with Number data type
    Result : Number,

    // Declare Finish for trigger to other connected port's input callback
    Finish : Function

    // Output can have many connection into the related input data type
};

// Input port
// Let's declare as `inputs` variable too, for easy access
var inputs = node.inputs = {
    // Declare A and validate this input as Number data type
    A : Number, // Primitive type can only have one cable connected

    // Declare B that will being called if any value
    // on connected output port was updated
    B : Blackprint.PortValidator(Number, function(value, Port){
        // value === Port.value
    }),

    // Declare Start as a callback to start the multiplication
    // Can have many cable connected
    Start : function(/* arguments */){
        // arguments are passed from the caller/output port of connected node

        // Let's call declared function below
        startMultiply();
    },

    // Accept Array of Number, can have many cable connected
    C : Blackprint.PortArrayOf(Number),
};

function startMultiply(){
    node.outputs.Result = inputs.A * inputs.B;

    node.outputs.Finish("We can send", "arguments too");
}
```