Ninja Power Manifesto


    1.0.5 • Public • Published


    NArrange is a .NET code beautifier that automatically organizes code members and elements within .NET classes.

    NArrange executes a Windows .exe executable (as a child process) and thus only works on a Windows environment.


    Install as a (dev) package dependency:

    npm install narrange -D

    Quick start

    From your node.js script, execute narrange.exe in a child process

    const { createNArrange } = require("narrange");
    const path = require("path");
    const { narrange, ctx } = createNArrange({
      srcPath: path.join(__dirname, "src/apps/mango"),
      configFilePath: path.join(__dirname, "config/NArrange.xml")
      // set debug mode
      // debugOn: true

    Note that the factory method createNArrange returns both narrange and a ctx context object. Look at the ctx object to ensure you have configured narrange correctly.

    During experimentation, pass debugOn: true as an option to createNArrange

    Pre-commit hooks

    You can use this recipe to integrate NArrange with git hooks, such as pre-commit hooks:

    • Setup git hooks via husky
    • Create node script to trigger on hook

    Setup hooks

    Install and setup husky

    Add the following to your package.json file (or create a new one using npm init)

      "devDependencies": {
        "narrange": "~1.0.0"
        "husky": "~1.3.1"
      "husky": {
        "hooks": {
          "pre-commit": "node format-csharp.js"

    Run npm install from your Terminal to install dependencies: husky and narrange

    Create node script

    Create a Node script format-csharp.js that runs narrange.exe on your source files using a config file with your specific preferences.

    Assuming we put the script in a /scripts folder in the project root

    const { createNArrange } = require("narrange");
    const path = require("path");
    const rootPath = path.join(__dirname, "../");
    const srcPath = path.join(rootPath, "Areas")
    const configFilePath = path.join(rootPath, "config/NArrange.xml")
    const { narrange } = createNArrange({

    Tabs configuration

    In case you want to convert spaces to tabs, you can use one of the included configuration files

    • config/Tabs4.xml converts 4 spaces to 1 tab
    • config/Tabs2.xml converts 2 spaces to 1 tab

    Assuming we put the script in a /scripts folder in the project root

    const path = require("path");
    const rootPath = path.join(__dirname, "../");
    const narrangeHomePath = path.join(rootPath, "node_modules/narrange");
    const narrangeConfigPath = path.join(narrangeHomePath, "config");
    // const narrangeLibPath = path.join(narrangeHomePath, "lib");
    const configFilePath = path.join(narrangeConfigPath, "Tabs4.xml")s


    To create your own formatting rules, by specifying your own rules in the <Formatting> section on the config file. Use any of the files included in config or lib folders of this package.

        <Tabs Style="Tabs" SpacesPerTab="2"/>
        <ClosingComments Enabled="false" Format="End $(ElementType) $(Name)"/>
        <Regions Style="NoDirective" />
        <Usings MoveTo="Namespace"/>
        <LineSpacing RemoveConsecutiveBlankLines="true" />

    Note that you can use the narrange-config.exe to edit a configuration file using a GUI, which ensures you can only populate it with valid values.

    Simple tabs formatting configuration

    Simple configuration to force 2 spaces to be converted to a tab:

    const { narrange } = createNArrange({
      srcPath: path.join(__dirname, "src/apps/mango"),
      tabs: 4 // use instead of configFilePath to select built in Tabs config file


    The function createNArrange creates a child process which executes the narrange.exe executable. createNArrange accepts the following options:

    • onError custom stderr handler function
    • onOut custom stdout handler function
    • createMainHandler factory method to create main handler
    • createExitHandler factory method to create process exit handler
    • createWriters factory method to create writers (error, info, debug methods)
    • createCommand factory method to create the command to execute in the child process
    • exitHandler process exit handler function (takes precedence over factory)
    • mainHandler main handler function (takes precedence over factory)
    • srcPath path to input folder for narrange (location folder of source files to process)
    • configFilePath path to narrange config file
    • exePath path to narrange exe to override version available in this module
    • tabs spaces count to tabs used in formatting (used to select built in Tabs config file) - 2 or 4
    • debugOn turn debug mode on or off (default: false)

    Note that all these options are optional. If any option is left out, a default value is used.

    Custom narrange setup example :

    const { createNArrange } = require("narrange");
    const path = require("path");
    const createMainHandler = (opts = {}) => {
      return (err, stdout, stderr) => {
        // ..
        if (err) {
    const onError = (err) {
    const { narrange } = createNArrange({
      srcPath: path.join(__dirname, "src/apps/mango"),
      configFilePath: path.join(__dirname, "config/NArrange.xml"),
      // tabs: 2 // use instead of configFilePath to select built in Tabs config file


    narrange exports the following "building blocks":

    • exitHandler function
    • mainHandler function
    • createMainHandler factory function
    • createExitHandler factory function
    • createWriters function to create info, error, and debug functions
    • defaults config object
    • paths config object

    This should make it easy to build a custom narrange solution to suit your needs.

    Full script example

    The following example uses minimist to parse process args passed from shell.

    const path = require("path");
    const minimist = require('minimist');
    const { createNArrange } = require("narrange");
    const processArgs = process.argv.slice(2);
    const opts = {
      alias: {
        h: 'help',
        s: 'src',
        t: 'tabs'
    // args is an object, with key for each named argument
    const args = minimist(processArgs, opts);
    const defaults = {
      srcFolder: "./",
      tabs: 4
    if ( {
      -s src folder (default: ./ )
      -t spaces per tab (default: 4)
    const srcFolder = args.src || defaults.srcFolders;
    const tabs = args.tabs || defaults.tabs;
    const rootPath = path.join(__dirname, "..");
    const srcPath = path.join(rootPath, srcFolder),


    You can run some basic tests using jest

    $ npm test

    Note that the executable narrange.exe can only be executed on a Windows (perhaps also using Mono?) platform.

    More resources


    gits: PowerShell - Recurse Project

    Format-Document PowerShell function which leverages Recurse-Project and automates calling into Visual Studio’s Format Document command.

    function Format-Document {
        [parameter(ValueFromPipelineByPropertyName = $true)]
      Process {
        $ProjectName | %{
          Recurse-Project -ProjectName $_ -Action
            if($item.Type -eq 'Folder' -or !$item.Language)
            $win = $item.ProjectItem.Open('{7651A701-06E5-11D1-8EBD-00A0C90F26EA}')
            if ($win)
              Write-Host "Processing `"$($item.ProjectItem.Name)`"" [System.Threading.Thread]::Sleep(100) $win.Activate() $item.ProjectItem.Document.DTE.ExecuteCommand('Edit.FormatDocument') $item.ProjectItem.Document.DTE.ExecuteCommand('Edit.RemoveAndSort') $win.Close(1)

    Format-Document can be configured for Visual Studio and used to run your existing Format Document command on a subset of project files, using recurse project to iterate and select the files to be processed.


    More docs

    See [./] for more details on using narrange directly.


    See NArrange license terms


    npm i narrange

    DownloadsWeekly Downloads






    Unpacked Size

    652 kB

    Total Files


    Last publish


    • kmandrup