# libwrapper

**Repository Path**: kingecg/libwrapper

## Basic Information

- **Project Name**: libwrapper
- **Description**: 生成proxy对象来mock/拦截方法调用
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-07-09
- **Last Updated**: 2025-07-09

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# libwrapper

一个轻量级的 JavaScript 库，用于创建代理对象，简化方法调用和属性访问。通过 libwrapper，你可以轻松地拦截和自定义对象的方法调用，实现更灵活的编程模式。

## 安装

使用 npm 安装:

```bash
npm install libwrapper
```

## 使用示例

### 基本用法

```javascript
const makeProxy = require('libwrapper');

// 创建一个简单的代理对象
const proxy = makeProxy({
  methods: {
    hello: {
      handler: (call) => `Hello, ${call.args[0]}!`
    },
    add: {
      handler: (call) => call.args[0] + call.args[1]
    }
  }
});

// 调用代理方法
console.log(proxy.hello('World')); // 输出: Hello, World!
console.log(proxy.add(5, 3));      // 输出: 8
```

### 使用默认处理函数

当调用未定义的方法时，可以使用默认处理函数：

```javascript
const proxy = makeProxy({
  methods: {
    hello: {
      handler: (call) => `Hello, ${call.args[0]}!`
    }
  },
  defaultHandler: (call) => `Method '${call.name}' was called with args: ${JSON.stringify(call.args)}`
});

// 调用已定义的方法
console.log(proxy.hello('World')); // 输出: Hello, World!

// 调用未定义的方法
console.log(proxy.unknownMethod(1, 2, 3)); 
// 输出: Method 'unknownMethod' was called with args: [1,2,3]
```

### 链式调用

使用 `returnProxy` 选项可以实现链式调用：

```javascript
const proxy = makeProxy({
  methods: {
    start: {
      handler: {
        handler: (call) => console.log('Starting...'),
        returnProxy: true
      }
    },
    process: {
      handler: {
        handler: (call) => console.log(`Processing: ${call.args[0]}`),
        returnProxy: true
      }
    },
    end: {
      handler: (call) => console.log('Ending...')
    }
  }
});

// 链式调用
proxy.start().process('data').end();
// 输出:
// Starting...
// Processing: data
// Ending...
```

### 属性设置拦截

libwrapper 也可以拦截属性设置操作：

```javascript
const proxy = makeProxy({
  methods: {},
  defaultHandler: (call) => {
    if (call.name === '@propset') {
      console.log(`Property '${call.args[0]}' set to '${call.args[1]}'`);
    }
  }
});

// 设置属性
proxy.name = 'John';
// 输出: Property 'name' set to 'John'
```

## API 文档

### makeProxy(options)

创建一个代理对象，拦截方法调用和属性设置。

#### 参数

- `options` (Object): 配置选项
  - `methods` (Object, 可选): 方法处理函数映射
    - 键: 方法名
    - 值: 处理函数或处理函数对象
      - 如果是函数: `(call) => result`
      - 如果是对象: `{ handler: (call) => result, returnProxy: boolean }`
  - `defaultHandler` (Function, 可选): 默认处理函数，用于处理未定义的方法调用

#### 返回值

返回一个代理对象，可以调用定义的方法或设置属性。

#### 方法调用对象 (call)

当调用代理对象的方法时，处理函数会接收一个 `call` 对象，包含以下属性：

- `name` (String): 被调用的方法名
- `args` (Array): 传递给方法的参数数组

当设置代理对象的属性时，默认处理函数会接收一个特殊的 `call` 对象：

- `name`: 固定为 `'@propset'`
- `args`: 包含两个元素的数组 `[propertyName, propertyValue]`

## 高级用法

### 组合多个代理

```javascript
const makeProxy = require('libwrapper');

// 创建一个数据处理代理
const dataProcessor = makeProxy({
  methods: {
    process: {
      handler: (call) => `Processed: ${call.args[0]}`
    }
  }
});

// 创建一个日志代理
const logger = makeProxy({
  methods: {
    log: {
      handler: (call) => console.log(`[LOG] ${call.args[0]}`)
    }
  }
});

// 组合这两个代理
const app = makeProxy({
  methods: {
    data: {
      handler: () => dataProcessor
    },
    logger: {
      handler: () => logger
    }
  }
});

// 使用组合的代理
const processed = app.data().process('raw data');
app.logger().log(processed);
// 输出: [LOG] Processed: raw data
```

## 测试

运行测试:

```bash
npm test
```

## 贡献

欢迎贡献！请随时提交问题或拉取请求。

1. Fork 这个仓库
2. 创建你的特性分支 (`git checkout -b feature/amazing-feature`)
3. 提交你的更改 (`git commit -m 'Add some amazing feature'`)
4. 推送到分支 (`git push origin feature/amazing-feature`)
5. 打开一个拉取请求

## 许可证

MIT