# Merger

## Property

[Molds](/the-instance/group/mold.md)： 參數型別，可視為Interface或Type的功能。

Groups：[Group](/the-instance/group.md)群組，應用方法請至[How To Use](/the-instance/merger.md#how-to-use)查看。

```javascript
let merger = {
    molds: 'molds',
    groups: 'groups'
}
```

## TypeScript

如果你使用TypeScript，可以使用我們提供的Declaration File。

```javascript
import { Merger } from 'packhouse/types'

let merger: Merger = {}
```

## How To Use

我們可以藉由`merger`方法加入Merger，並傳遞Options，但我們不推薦這麼做，請參閱正規化方法[Main](/the-instance/main.md)。

{% hint style="info" %}
Merger會以[`namespace@`](/the-instance/merger.md#sign)的Sign建立Mold與Group。
{% endhint %}

### Molds

Merger的Mold會被註冊進Core Mold中，各地都能引用。

```javascript
const group = {
    tools: {
        sum: {
            request: ['myMerger@int', 'myMerger@int'],
            handler(self, v1, v2) {
                self.success(v1 + v2)
            }
        }
    }
}

const merger = {
    molds: {
        int(value) {
            return Math.floor(value)
        }
    }
}

packhouse.merger('myMerger', merger)
packhouse.addGroup('math', group)

packhouse.tool('math/sum').action(1.1, 2.5, (err, result) => {
    console.log(result) // 3
})
```

### Groups

```javascript
const group = {
    tools: {
        sum: {
            handler(self, v1, v2) {
                self.success(v1 + v2)
            }
        }
    }
}

const merger = {
    groups: {
        math(options) {
            console.log(options.PI) // 3.14159...
            return {
                data: group
            }
        }
    }
}

packhouse.merger('myMerger', merger, {
    PI: Math.PI
})

packhouse.tool('myMerger@math/sum').action(...)
```

## Module

Merger的另一個特點是內部引用，當Merger互相引用對方時不需要添加`sign`。

```javascript
let group1 = {
    tools: {
        sum: {
            handler(self, v1, v2) {
                self.success(v1 + v2)
            }
        }
    }
}

let group2 = {
    mergers: {
        mySumGroup: 'sumGroup'
    },
    tools: {
        double: {
            install({ include }) {
                include('sum').tool('mySumGroup/sum')
            },
            handler(self, v1) {
                self.tool('sum').action(v1, v1, (e, r) => {
                    self.success(r)
                })
            }
        }
    }
}

let merger = {
    groups: {
        sumGroup() {
            return {
                data: group1
            }
        },
        doubleGroup() {
            return {
                data: group2
            }
        }
    }
}

packhouse.merger('myMerger', merger)

packhouse.tool('myMerger@doubleGroup/double').action(10, (e, r) => {
    console.log(r) // 20
})
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://packhouse-doc.metalsheep.com/the-instance/merger.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.