# nv-data-tree-bp-agg

> nv-data-tree-bp-agg ======================== - nv-data-tree-bp-agg - a simple expression runner - for test "parallel" exprs excution

Latest version **1.0.1** (published 2022-06-19) · ISC license · 0 weekly downloads

## Install

```sh
npm install nv-data-tree-bp-agg
pnpm add nv-data-tree-bp-agg
yarn add nv-data-tree-bp-agg
bun add nv-data-tree-bp-agg
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.1 |
| Published | 2022-06-19 |
| First published | 2022-06-19 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 4 |
| Unpacked size | 22.9 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Maintainers | ihgazni2 |

## Links

- npm: https://www.npmjs.com/package/nv-data-tree-bp-agg
- npm.io page: https://npm.io/package/nv-data-tree-bp-agg

## Dependencies (4)

- [nv-string-basic](https://npm.io/package/nv-string-basic.md) ^1.0.46
- [nv-facutil-basic](https://npm.io/package/nv-facutil-basic.md) ^1.3.11
- [nv-data-tree-csp-node](https://npm.io/package/nv-data-tree-csp-node.md) ^1.1.10
- [nv-data-tree-csp-forest](https://npm.io/package/nv-data-tree-csp-forest.md) ^1.0.24

## Recent versions

- 1.0.1 (latest) — 2022-06-19

## README

nv-data-tree-bp-agg
========================
- nv-data-tree-bp-agg
- a simple expression runner
- for test "parallel" exprs excution

- ONLY support SYNC executor

- its a simplified pure-JS version of nv-task-aggregating-promise(which support async executor) in nvlang

install
=======
- npm install nv-data-tree-bp-agg

usage
=====

      const {load_calc_from_bp} = require("nv-data-tree-bp-agg")

### load         [...code...] is quotes of code

        // this means   ((1,2,3)+ , (5,3)-) *     , in a suffix-style
        //     *(+(1,2,3),-(5,3))
        //     (1+2+3) * (5-3)         

        var bp =`
        {
           {[1] ,[2] ,[3]} -> [+]
           {[5], [3]}      -> [-]
        } -> [*] 
        `;




        var calc = load_calc_from_bp(bp)
        calc.reset()
        /*
        > calc.show()
        {
            {
                {
                    [1 : opened]-|
                    [2 : opened]-|
                    [3 : opened]-|
                }-> [+ : ready]     -|
                {
                    [5 : opened]-|
                    [3 : opened]-|
                }-> [- : ready]     -|
            }-> [* : ready]         -|
        }-> [0 : ready]

        > calc.list_all_tags()
        [
          0,   '*', '+', '1',
          '2', '3', '-', '5',
          '3'
        ]
        >
        */


### assign function IR


        calc.set_calculator_via_tag('+',(RETURN,self)=>{
            let children = self.$children_;
            let sum = 0;
            for(let nd of children) {
                sum = sum + nd.rslt_
            }
            RETURN(sum)
        });
        calc.set_calculator_via_tag('-',(RETURN,self)=>{
            let children = self.$children_;
            let sub = children[0].rslt_;
            for(let i =1;i<children.length;i++) {
                let nd = children[i];
                sub = sub-nd.rslt_
            }
            RETURN(sub)
        });
        calc.set_calculator_via_tag('*',(RETURN,self)=>{
            let children = self.$children_;
            let mul = 1;
            for(let nd of children) {
                mul = mul * nd.rslt_
            }
            RETURN(mul)
        });

        calc.set_calculator_via_tag_fltr(
            (r)=>typeof(r)==='string'  && /^[0-9]+$/.test(r),
            (RETURN,self)=>{
                RETURN(Number(self["#raw_tag"]))
           }
        );



### run to complete

        var r = calc.run_to_complete()
        /*
               // 12 === (1+2+3) * (5-3)  
        12
        */

### single step mode


        calc.reset();

        calc.next()

        /*
        >
        [ 1, 2, 3, 5, 3 ]
        */

        /*
        > calc.show()
        {
            {
                {
                    [1 : 1 # [resolved]-|
                    [2 : 2 # [resolved]-|
                    [3 : 3 # [resolved]-|
                }-> [+ # opened]           -|
                {
                    [5 : 5 # [resolved]-|
                    [3 : 3 # [resolved]-|
                }-> [- # opened]           -|
            }-> [* # ready]                -|
        }-> [0 # ready]

        */


        calc.next()

        /*
        [6,2]
        */

        /*
        > calc.show()
        {
            {
                {
                    [1 : 1 # [resolved]-|
                    [2 : 2 # [resolved]-|
                    [3 : 3 # [resolved]-|
                }-> [+ : 6 # [resolved]    -|
                {
                    [5 : 5 # [resolved]-|
                    [3 : 3 # [resolved]-|
                }-> [- : 2 # [resolved]    -|
            }-> [* # opened]               -|
        }-> [0 # ready]

        */

        /*
        > calc.next()
        [ 12 ]
        >
        > calc.show()
        {
            {
                {
                    [1 : 1 # [resolved] -|
                    [2 : 2 # [resolved] -|
                    [3 : 3 # [resolved] -|
                }-> [+ : 6 # [resolved]     -|
                {
                    [5 : 5 # [resolved] -|
                    [3 : 3 # [resolved] -|
                }-> [- : 2 # [resolved]     -|
            }-> [* : 12 # [resolved]        -|
        }-> [0 # opened]

        */

        /*
        > calc.next()
        [ 12 ]
        > calc.show()
        {
            {
                {
                    [1 : 1 # [resolved] -|
                    [2 : 2 # [resolved] -|
                    [3 : 3 # [resolved] -|
                }-> [+ : 6 # [resolved]     -|
                {
                    [5 : 5 # [resolved] -|
                    [3 : 3 # [resolved] -|
                }-> [- : 2 # [resolved]     -|
            }-> [* : 12 # [resolved]        -|
        }-> [0 : 12 # [resolved]

        */

        calc.reset()


METHODS
=======

### Calc

        calc.get_nds_with_tag             calc.get_nds_with_tag_fltr
        calc.get_nds_with_tag_rgx         calc.list_all_tags                calc.next
        calc.reset                        calc.run_to_complete              calc.set_calculator_via_tag
        calc.set_calculator_via_tag_fltr  calc.set_calculator_via_tag_rgx   calc.shape_bp_
        calc.show


### BpAgg

        nd.dump_shape
        nd.is_can_exec                             nd.is_opened
        nd.is_ready                                nd.is_resolved
        nd.rslt_                                   nd.run
        nd.set_state_to_opened                     nd.set_state_to_ready
        nd.set_state_to_resolved                   nd.show
        nd.state_                                  nd.step
        nd.step_without_noti_parent                nd.to_str
        nd.calculator                              nd.stringify



APIS
====

        {
          load_calc_from_bp: [Function: load_calc_from_bp],
          Calc: [class Calc extends Array],
          BpAgg: [class BpAgg extends ‌] {
            STATES_MD: {
              '0': 'ready',
              '2': 'opened',
              '4': 'resolved',
              ready: 0,
              opened: 2,
              resolved: 4
            },
            DFLT_AGG_CALCULATOR: [Function: DFLT_AGG_CALCULATOR]
          },
          _eng: { load: [Function: load], dump: [Function: dump] },
          _paint: [Function: paint],
          _parser: {
            DFLT_TAG_PARSER: [Function: DFLT_TAG_PARSER],
            DFLT_SET_TAG: [Function: DFLT_SET_TAG],
            DFLT_GET_TAG: [Function: DFLT_GET_TAG],
            parse: [Function: parse]
          },
          _repr: { show: [Function: show] },
          _load: { load: [Function: load] }
        }


LICENSE
=======
- ISC

---
_Source: https://npm.io/package/nv-data-tree-bp-agg · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._
