nexfep 0.1.7 → 0.3.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 zhuxiaojt
+Copyright (c) 2026 Nexfteam
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README-CN.md

@@ -22,6 +22,10 @@ Nexfep 是一个基于 [@webviewjs/webview](https://github.com/webviewjs/webview
 - **IPC 通信** — 支持主进程与 WebView 之间的双向消息通信，通过注入的函数进行调用
 - **窗口控制** — 提供最大化、最小化、关闭、标题设置、开发者工具等完整窗口操作 API
 - **拖拽区域** — 内置 HTML 属性支持，方便定义窗口拖拽区域（`nexfep-area-drag` 等）
+- **系统托盘** — 创建和管理系统托盘图标及右键菜单
+- **桌面通知** — 通过 `app.utils.notify()` 发送桌面通知
+- **日志系统** — 内置 Logger，支持文件日志和彩色控制台输出，自动拦截页面 console 消息
+- **CLI 构建工具** — 通过 `nexfep build` 将应用打包为独立可执行文件
 - **TypeScript 支持** — 完整的类型定义，开发体验优秀
 
 ## 安装
@@ -33,30 +37,151 @@ pnpm add nexfep
 ## 快速开始
 
 ```typescript
-import { WindowPool } from 'nexfep';
+import { Application } from 'nexfep';
 
-const pool = new WindowPool();
+const app = new Application();
 
-const window = await pool.createWindow(true, false);
+const window = await app.windows.createWindow(true, false);
 
 await window.loadHTML('<h1 nexfep-area-drag>Hello Nexfep!</h1>');
-
-pool.mainloop();
 ```
 
 ## 使用指南
 
-### 窗口池
+### Application
 
-`WindowPool` 是框架的核心管理类，负责窗口的创建和回收。
+`Application` 是框架的主入口，负责管理应用生命周期，提供窗口、系统托盘和日志的访问。
 
 ```typescript
-const pool = new WindowPool();
+import { Application } from 'nexfep';
+
+const app = new Application();
+// 或指定自定义 WebView2 用户数据目录（仅 Windows 生效）
+const app = new Application({ WindowsWebview2UserDataFolder: 'C:\\custom\\webview2-data' });
+// 或指定日志文件路径
+const app = new Application({ LogFilePath: './app.log' });
 ```
 
 **构造函数参数**
 
-- `WindowsWebview2UserDataFolder`（可选）— WebView2 用户数据目录，默认为 `%LOCALAPPDATA%\NexfepDevelopment.webview2-data`
+| 选项 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `WindowsWebview2UserDataFolder` | `string`（可选） | `%LOCALAPPDATA%\NexfepDevelopment.webview2-data` | WebView2 用户数据目录（仅 Windows） |
+| `LogFilePath` | `string`（可选） | 无 | 日志文件输出路径 |
+
+**属性**
+
+- `windows` — `WindowPool` 实例，用于管理浏览器窗口
+- `utils` — 工具方法（如桌面通知）
+- `logger` — `Logger` 实例，用于日志记录
+
+**方法**
+
+- `createTray(options)` — 创建系统托盘图标和右键菜单
+- `exit()` — 退出应用
+
+### Logger
+
+Logger 支持文件输出和彩色控制台输出，可通过 `app.logger` 访问。
+
+```typescript
+app.logger.log('Hello World');
+app.logger.error('发生错误');
+app.logger.warn('警告信息');
+app.logger.info('提示信息');
+app.logger.debug('调试信息');
+```
+
+**方法**
+
+| 方法 | 说明 |
+|------|------|
+| `log(message)` | 记录日志 |
+| `error(message)` | 记录错误日志（红色） |
+| `warn(message)` | 记录警告日志（黄色） |
+| `info(message)` | 记录提示日志（蓝色） |
+| `debug(message)` | 记录调试日志（灰色） |
+
+每个方法接受字符串或字符串数组作为参数。
+
+**页面 Console 拦截**
+
+页面中的 `console.log`、`console.error`、`console.info`、`console.warn`、`console.debug` 调用会被自动拦截并转发到主进程 Logger，输出中包含来源窗口的 ID。
+
+### 托盘图标
+
+通过 `app.createTray()` 创建和管理系统托盘图标及右键菜单。
+
+```typescript
+import { readFileSync } from 'fs';
+
+const tray = app.createTray({
+  id: 'my-tray',
+  tooltip: '我的应用',
+  icon: {
+    data: readFileSync('./icon.png'),
+    width: 32,
+    height: 32,
+  },
+  menuItems: [
+    { id: 'show', label: '显示窗口' },
+    { id: 'quit', label: '退出' },
+  ],
+});
+```
+
+`icon` 字段接受 `TrayIconImage` 对象：
+
+```typescript
+interface TrayIconImage {
+  data: Buffer;      // 图片二进制数据
+  width?: number;    // 可选宽度
+  height?: number;   // 可选高度
+}
+```
+
+**方法**
+
+| 方法                                         | 描述               |
+|---------------------------------------------|--------------------|
+| `addMenuItem(item)`                         | 添加菜单项          |
+| `removeMenuItem(id)`                        | 按 ID 删除菜单项    |
+| `setMenuItems(items)`                       | 替换所有菜单项      |
+| `setIcon(icon, width?, height?)`            | 更改托盘图标（原始像素数据 `Uint8Array` / `number[]`） |
+| `setTooltip(tooltip)`                       | 更改悬停提示文本    |
+| `on(event, callback)`                       | 监听托盘事件（如 `'click'`） |
+| `show()`                                    | 显示托盘图标        |
+| `hide()`                                    | 隐藏托盘图标        |
+| `destroy()`                                 | 销毁托盘图标        |
+
+```typescript
+tray.on('click', () => {
+  console.log('托盘被点击');
+});
+tray.addMenuItem({ id: 'about', label: '关于' });
+tray.setTooltip('Nexfep 应用');
+```
+
+### 桌面通知
+
+通过 `app.utils.notify()` 发送桌面通知。
+
+```typescript
+const notification = app.utils.notify('标题', '通知内容');
+```
+
+**参数**
+
+- `title` — 通知标题
+- `body`（可选）— 通知正文
+
+### 窗口池
+
+`WindowPool` 是框架的核心管理类，负责窗口的创建和回收。
+
+```typescript
+const pool = app.windows;
+```
 
 ### 窗口创建
 
@@ -78,6 +203,7 @@ window.maximize();
 window.minimize();
 window.close();
 window.setTitle('新标题');
+window.setSize(800, 600);
 window.openDevTools();
 ```
 
@@ -183,9 +309,9 @@ const value = await window.getGlobal('hello');
 
 - `name` — 全局变量名称
 
-#### 全局变量Map
+#### 全局变量 Map
 
-在主进程中通过 `WindowPool.global` 获取一个包含所有全局变量的 `Map<string, any>` 对象，可对其进行设置、获取等操作：
+在主进程中通过 `pool.global` 获取一个包含所有全局变量的 `Map<string, any>` 对象，可对其进行设置、获取等操作：
 
 ```typescript
 const globals = pool.global;
@@ -336,41 +462,94 @@ if (window.isNexfepLoadDone) {
 }
 ```
 
+## CLI
+
+Nexfep 提供命令行工具，用于将应用打包为独立可执行文件。
+
+### 用法
+
+```bash
+npx nexfep build [options]
+```
+
+### 选项
+
+| 选项 | 说明 |
+|------|------|
+| `-n, --name <name>` | 应用名称（默认：来自 package.json） |
+| `-e, --entry <file>` | 入口文件路径（默认：来自 package.json main） |
+| `-o, --output <dir>` | 输出目录（默认：dist） |
+| `-i, --ignore <pattern>` | 要忽略的文件或目录（可多次使用） |
+| `-c, --console` | 在 Windows 上显示控制台窗口（默认：false） |
+| `-r, --reinstall` | 构建前仅重新安装生产依赖 |
+| `-s, --skip-clean` | 跳过清理旧的构建文件 |
+| `-u, --upx <level>` | 使用 UPX 压缩可执行文件，级别 0-9（默认：0） |
+
+### 示例
+
+```bash
+# 使用 package.json 默认配置构建
+nexfep build
+
+# 设置自定义应用名称和入口文件
+nexfep build -n my-app -e ./src/index.js
+
+# 设置自定义输出目录
+nexfep build -o ./build
+
+# 忽略多个模式
+nexfep build -i node_modules -i test -i temp
+
+# 使用 UPX 压缩构建
+nexfep build -u 7
+```
+
+该命令使用 [nexfpack](https://github.com/nexfteam/Nexfpack) 将应用打包为独立可执行文件。
+
 ## API
 
+### Application
+
+| 方法/属性 | 参数 | 返回值 | 说明 |
+|-----------|------|--------|------|
+| `constructor(options?)` | `{ WindowsWebview2UserDataFolder?, LogFilePath? }` | Application | 创建应用实例 |
+| `windows` | / | WindowPool | 窗口池实例 |
+| `utils` | / | \_\_Utils | 工具方法（通知） |
+| `logger` | / | Logger | 日志实例 |
+| `createTray(options)` | 见 Tray 章节 | Tray | 创建系统托盘图标 |
+| `exit()` | 无 | void | 退出应用 |
+
 ### WindowPool
 
-| 方法/属性                                 | 参数                                                          | 返回值              | 说明                         |
-| ------------------------------------- | ----------------------------------------------------------- | ---------------- | -------------------------- |
-| `constructor(userDataFolder?)`        | `userDataFolder`: string（可选）                                | WindowPool       | 创建窗口池，可选指定 WebView2 用户数据目录 |
-| `createWindow(isShow?, isDecorated?)` | `isShow`: boolean（默认 true）, `isDecorated`: boolean（默认 true） | Promise\<Window> | 创建并获取一个窗口                  |
-| `handle(event, callback)`             | `event`: string, `callback`: (data: string) => void | 无                | 监听指定事件，当收到事件时触发回调函数 |
-| `unhandle(event, callback)`                     | `event`: string, `callback`: (data: string) => void | 无                | 取消监听指定事件回调中的指定函数 |
-| `global`                              | /                                                                          | Map\<string, any> | 全局变量Map，类型为 `Map<string, any>`                         |
-| `closeWindow(window)`                 | `window`: Window                                            | Promise\<void>   | 关闭指定窗口并回收至池中               |
-| `closePool()`                         | 无                                                           | Promise\<void>   | 关闭窗口池，退出应用                 |
-| `mainloop()`                          | 无                                                           | void             | 启动应用主循环，阻塞直到应用退出           |
-| `onCustomMessage`                     | `(window: Window, data: string) => void`                    | 无                | 自定义消息回调函数，当收到页面发来的自定义消息时触发 |
+| 方法/属性 | 参数 | 返回值 | 说明 |
+|-----------|------|--------|------|
+| `createWindow(isShow?, isDecorated?)` | `isShow`: boolean（默认 true）, `isDecorated`: boolean（默认 true） | Promise\<Window> | 创建并获取一个窗口 |
+| `handle(event, callback)` | `event`: string, `callback`: (data: any) => any | 无 | 监听指定事件 |
+| `unhandle(event, callback)` | `event`: string, `callback`: (data: any) => any | 无 | 取消监听指定事件 |
+| `global` | / | Map\<string, any> | 全局变量 Map |
+| `closeWindow(window)` | `window`: Window | Promise\<void> | 关闭指定窗口并回收至池中 |
+| `onCustomMessage` | `(window: Window, data: string) => void` | 无 | 自定义消息回调函数 |
 
 ### Window
 
-| 方法/属性                       | 参数                                | 返回值            | 说明            |
-| --------------------------- | --------------------------------- | -------------- | ------------- |
-| `loadURL(url)`              | `url`: string — 要加载的网页地址          | Promise\<void> | 加载指定 URL      |
-| `loadHTML(html)`            | `html`: string — HTML 字符串         | Promise\<void> | 加载指定 HTML 内容  |
-| `show()`                    | 无                                 | void           | 显示窗口          |
-| `hide()`                    | 无                                 | void           | 隐藏窗口          |
-| `maximize()`                | 无                                 | void           | 最大化窗口         |
-| `unMaximize()`              | 无                                 | void           | 还原窗口（取消最大化）   |
-| `minimize()`                | 无                                 | void           | 最小化窗口         |
-| `unMinimize()`              | 无                                 | void           | 还原窗口（取消最小化）   |
-| `close()`                   | 无                                 | void           | 关闭窗口并回收至池中    |
-| `setTitle(title)`           | `title`: string — 窗口标题            | void           | 设置窗口标题        |
-| `setDecorated(isDecorated)` | `isDecorated`: boolean — 是否使用系统装饰 | void           | 设置窗口是否带边框和标题栏 |
-| `resizable(resizable)`      | `resizable`: boolean — 是否可调整大小    | void           | 设置窗口是否可调整大小   |
-| `openDevTools()`            | 无                                 | void           | 打开开发者工具       |
-| `closeDevTools()`           | 无                                 | void           | 关闭开发者工具       |
-| `id`                        | 无                                 | number         | 窗口唯一标识，自增编号   |
+| 方法/属性 | 参数 | 返回值 | 说明 |
+|-----------|------|--------|------|
+| `loadURL(url)` | `url`: string — 要加载的网页地址 | Promise\<void> | 加载指定 URL |
+| `loadHTML(html)` | `html`: string — HTML 字符串 | Promise\<void> | 加载指定 HTML 内容 |
+| `show()` | 无 | void | 显示窗口 |
+| `hide()` | 无 | void | 隐藏窗口 |
+| `maximize()` | 无 | void | 最大化窗口 |
+| `unMaximize()` | 无 | void | 还原窗口（取消最大化） |
+| `minimize()` | 无 | void | 最小化窗口 |
+| `unMinimize()` | 无 | void | 还原窗口（取消最小化） |
+| `close()` | 无 | void | 关闭窗口并回收至池中 |
+| `setTitle(title)` | `title`: string | void | 设置窗口标题 |
+| `setDecorated(isDecorated)` | `isDecorated`: boolean | void | 设置窗口是否带边框和标题栏 |
+| `resizable(resizable)` | `resizable`: boolean | void | 设置窗口是否可调整大小 |
+| `setSize(width, height)` | `width`: number, `height`: number | void | 设置窗口尺寸（像素） |
+| `openDevTools()` | 无 | void | 打开开发者工具 |
+| `closeDevTools()` | 无 | void | 关闭开发者工具 |
+| `id` | 无 | number | 窗口唯一标识，自增编号 |
 
 ## 开发
 

package/README.md

@@ -22,6 +22,10 @@ The framework uses a window pool management mechanism, supporting multi-window a
 - **IPC Communication** — Supports bidirectional message communication between the main process and WebView, via injected functions
 - **Window Control** — Provides complete window operation APIs including maximize, minimize, close, title setting, and developer tools
 - **Drag Regions** — Built-in HTML attribute support for defining window drag regions (`nexfep-area-drag`, etc.)
+- **System Tray** — Create and manage system tray icons with context menus
+- **Desktop Notifications** — Send desktop notifications via `app.utils.notify()`
+- **Logging System** — Built-in logger with file output and colored console support, with automatic interception of page console messages
+- **CLI Build Tool** — Package your application into a standalone executable via `nexfep build`
 - **TypeScript Support** — Complete type definitions for excellent development experience
 
 ## Installation
@@ -33,30 +37,151 @@ pnpm add nexfep
 ## Quick Start
 
 ```typescript
-import { WindowPool } from 'nexfep';
+import { Application } from 'nexfep';
 
-const pool = new WindowPool();
+const app = new Application();
 
-const window = await pool.createWindow(true, false);
+const window = await app.windows.createWindow(true, false);
 
 await window.loadHTML('<h1 nexfep-area-drag>Hello Nexfep!</h1>');
-
-pool.mainloop();
 ```
 
 ## Usage Guide
 
-### Window Pool
+### Application
 
-`WindowPool` is the core management class of the framework, responsible for window creation and recycling.
+`Application` is the main entry point of the framework, responsible for managing the application lifecycle and providing access to windows, system tray, and logger.
+
+```typescript
+import { Application } from 'nexfep';
+
+const app = new Application();
+// or with custom WebView2 user data directory (Windows only)
+const app = new Application({ WindowsWebview2UserDataFolder: 'C:\\custom\\webview2-data' });
+// or with log file path
+const app = new Application({ LogFilePath: './app.log' });
+```
+
+**Constructor Options**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `WindowsWebview2UserDataFolder` | `string` (optional) | `%LOCALAPPDATA%\NexfepDevelopment.webview2-data` | WebView2 user data directory (Windows only) |
+| `LogFilePath` | `string` (optional) | none | File path for log output |
+
+**Properties**
+
+- `windows` — The `WindowPool` instance for managing browser windows
+- `utils` — Utility methods (e.g., desktop notifications)
+- `logger` — The `Logger` instance for logging
+
+**Methods**
+
+- `createTray(options)` — Create a system tray icon with context menu
+- `exit()` — Exit the application
+
+### Logger
+
+The logger supports both file output and colored console output. It can be accessed via `app.logger`.
 
 ```typescript
-const pool = new WindowPool();
+app.logger.log('Hello World');
+app.logger.error('An error occurred');
+app.logger.warn('Warning message');
+app.logger.info('Info message');
+app.logger.debug('Debug message');
 ```
 
-**Constructor Parameters**
+**Methods**
+
+| Method | Description |
+|--------|-------------|
+| `log(message)` | Log a message |
+| `error(message)` | Log an error message (red) |
+| `warn(message)` | Log a warning message (yellow) |
+| `info(message)` | Log an info message (blue) |
+| `debug(message)` | Log a debug message (gray) |
+
+Each method accepts either a string or an array of strings.
+
+**Page Console Interception**
 
-- `WindowsWebview2UserDataFolder` (optional) — WebView2 user data directory, defaults to `%LOCALAPPDATA%\NexfepDevelopment.webview2-data`
+Console calls (`console.log`, `console.error`, `console.info`, `console.warn`, `console.debug`) in the page are automatically intercepted and forwarded to the main process logger, with the source window ID included in the output.
+
+### Tray
+
+Create and manage system tray icons with context menus via `app.createTray()`.
+
+```typescript
+import { readFileSync } from 'fs';
+
+const tray = app.createTray({
+  id: 'my-tray',
+  tooltip: 'My App',
+  icon: {
+    data: readFileSync('./icon.png'),
+    width: 32,
+    height: 32,
+  },
+  menuItems: [
+    { id: 'show', label: 'Show Window' },
+    { id: 'quit', label: 'Quit' },
+  ],
+});
+```
+
+The `icon` field accepts a `TrayIconImage` object:
+
+```typescript
+interface TrayIconImage {
+  data: Buffer;      // Image binary data
+  width?: number;    // Optional width
+  height?: number;   // Optional height
+}
+```
+
+**Methods**
+
+| Method                                      | Description                         |
+|---------------------------------------------|-------------------------------------|
+| `addMenuItem(item)`                         | Add a menu item                     |
+| `removeMenuItem(id)`                        | Remove a menu item by ID            |
+| `setMenuItems(items)`                       | Replace all menu items              |
+| `setIcon(icon, width?, height?)`            | Change the tray icon (raw pixel data as `Uint8Array` / `number[]`) |
+| `setTooltip(tooltip)`                       | Change the tooltip text             |
+| `on(event, callback)`                       | Listen for tray events (e.g. `'click'`) |
+| `show()`                                    | Show the tray icon                  |
+| `hide()`                                    | Hide the tray icon                  |
+| `destroy()`                                 | Destroy the tray icon               |
+
+```typescript
+tray.on('click', () => {
+  console.log('Tray clicked');
+});
+tray.addMenuItem({ id: 'about', label: 'About' });
+tray.setTooltip('Nexfep App');
+```
+
+### Notifications
+
+Send desktop notifications via `app.utils.notify()`.
+
+```typescript
+const notification = app.utils.notify('Title', 'Notification body');
+```
+
+**Parameters**
+
+- `title` — Notification title
+- `body` (optional) — Notification body text
+
+### Window Pool
+
+`WindowPool` is the core management class of the framework, responsible for window creation and recycling.
+
+```typescript
+const pool = app.windows;
+```
 
 ### Window Creation
 
@@ -78,6 +203,7 @@ window.maximize();
 window.minimize();
 window.close();
 window.setTitle('New Title');
+window.setSize(800, 600);
 window.openDevTools();
 ```
 
@@ -185,7 +311,7 @@ const value = await window.getGlobal('hello');
 
 #### Global Variable Map
 
-Get a `Map<string, any>` containing all global variables via `WindowPool.global` in the main process, which supports operations like set and get:
+Get a `Map<string, any>` containing all global variables via `pool.global` in the main process, which supports operations like set and get:
 
 ```typescript
 const globals = pool.global;
@@ -336,41 +462,94 @@ if (window.isNexfepLoadDone) {
 }
 ```
 
+## CLI
+
+Nexfep provides a command-line tool for building applications into standalone executables.
+
+### Usage
+
+```bash
+npx nexfep build [options]
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-n, --name <name>` | Application name (default: from package.json) |
+| `-e, --entry <file>` | Entry file path (default: from package.json main) |
+| `-o, --output <dir>` | Output directory (default: dist) |
+| `-i, --ignore <pattern>` | Files or directories to ignore (can be used multiple times) |
+| `-c, --console` | Show console window on Windows (default: false) |
+| `-r, --reinstall` | Reinstall production dependencies only before building |
+| `-s, --skip-clean` | Skip cleaning old build files before building |
+| `-u, --upx <level>` | Use UPX to compress the executable, level 0-9 (default: 0) |
+
+### Examples
+
+```bash
+# Build using defaults from package.json
+nexfep build
+
+# Set custom application name and entry file
+nexfep build -n my-app -e ./src/index.js
+
+# Set custom output directory
+nexfep build -o ./build
+
+# Ignore multiple patterns
+nexfep build -i node_modules -i test -i temp
+
+# Build with UPX compression
+nexfep build -u 7
+```
+
+This command uses [nexfpack](https://github.com/nexfteam/Nexfpack) to package your application into a standalone executable.
+
 ## API
 
+### Application
+
+| Method/Property | Parameters | Return Value | Description |
+|----------------|-----------|--------------|-------------|
+| `constructor(options?)` | `{ WindowsWebview2UserDataFolder?, LogFilePath? }` | Application | Creates the application instance |
+| `windows` | / | WindowPool | The window pool instance |
+| `utils` | / | \_\_Utils | Utility methods (notifications) |
+| `logger` | / | Logger | The logger instance |
+| `createTray(options)` | see Tray section | Tray | Creates a system tray icon |
+| `exit()` | None | void | Exits the application |
+
 ### WindowPool
 
-| Method/Property                       | Parameters                                                                 | Return Value     | Description                                                              |
-| ------------------------------------- | -------------------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------ |
-| `constructor(userDataFolder?)`        | `userDataFolder`: string (optional)                                        | WindowPool       | Creates a window pool, optionally specifying the WebView2 user data directory |
-| `createWindow(isShow?, isDecorated?)` | `isShow`: boolean (default true), `isDecorated`: boolean (default true)    | Promise\<Window> | Creates and returns a window                                             |
-| `handle(event, callback)`             | `event`: string, `callback`: (data: string) => void                        | None             | Listens for the specified event, triggers callback when event is received |
-| `unhandle(event, callback)`           | `event`: string, `callback`: (data: string) => void                        | None             | Removes the specified callback from the event listener                     |
-| `global`                              | /                                                                          | Map\<string, any> | A global variable map of type: `Map<string, any>`                         |
-| `closeWindow(window)`                 | `window`: Window                                                           | Promise\<void>   | Closes the specified window and returns it to the pool                   |
-| `closePool()`                         | None                                                                       | Promise\<void>   | Closes the window pool and exits the application                         |
-| `mainloop()`                          | None                                                                       | void             | Starts the application main loop, blocking until the application exits   |
-| `onCustomMessage`                     | `(window: Window, data: string) => void`                                   | None             | Custom message callback, triggered when receiving custom messages from pages |
+| Method/Property | Parameters | Return Value | Description |
+|----------------|-----------|--------------|-------------|
+| `createWindow(isShow?, isDecorated?)` | `isShow`: boolean (default true), `isDecorated`: boolean (default true) | Promise\<Window> | Creates and returns a window |
+| `handle(event, callback)` | `event`: string, `callback`: (data: any) => any | None | Listens for the specified event |
+| `unhandle(event, callback)` | `event`: string, `callback`: (data: any) => any | None | Removes the specified event listener |
+| `global` | / | Map\<string, any> | A global variable map |
+| `closeWindow(window)` | `window`: Window | Promise\<void> | Closes the specified window and returns it to the pool |
+| `onCustomMessage` | `(window: Window, data: string) => void` | None | Custom message callback |
 
 ### Window
 
-| Method/Property                       | Parameters                                  | Return Value     | Description                              |
-| ------------------------------------- | ------------------------------------------- | ---------------- | ---------------------------------------- |
-| `loadURL(url)`                        | `url`: string — URL to load                 | Promise\<void>   | Loads the specified URL                 |
-| `loadHTML(html)`                      | `html`: string — HTML string                | Promise\<void>   | Loads the specified HTML content        |
-| `show()`                              | None                                        | void             | Shows the window                         |
-| `hide()`                              | None                                        | void             | Hides the window                         |
-| `maximize()`                          | None                                        | void             | Maximizes the window                     |
-| `unMaximize()`                        | None                                        | void             | Restores the window (cancels maximize)   |
-| `minimize()`                          | None                                        | void             | Minimizes the window                     |
-| `unMinimize()`                        | None                                        | void             | Restores the window (cancels minimize)   |
-| `close()`                             | None                                        | void             | Closes the window and returns to pool    |
-| `setTitle(title)`                     | `title`: string — Window title              | void             | Sets the window title                   |
-| `setDecorated(isDecorated)`           | `isDecorated`: boolean — Use system decorations | void          | Sets whether the window has borders and title bar |
-| `resizable(resizable)`                | `resizable`: boolean — Resizable            | void             | Sets whether the window is resizable     |
-| `openDevTools()`                      | None                                        | void             | Opens developer tools                   |
-| `closeDevTools()`                     | None                                        | void             | Closes developer tools                  |
-| `id`                                  | None                                        | number           | Unique window identifier, auto-incrementing |
+| Method/Property | Parameters | Return Value | Description |
+|----------------|-----------|--------------|-------------|
+| `loadURL(url)` | `url`: string — URL to load | Promise\<void> | Loads the specified URL |
+| `loadHTML(html)` | `html`: string — HTML string | Promise\<void> | Loads the specified HTML content |
+| `show()` | None | void | Shows the window |
+| `hide()` | None | void | Hides the window |
+| `maximize()` | None | void | Maximizes the window |
+| `unMaximize()` | None | void | Restores the window (cancels maximize) |
+| `minimize()` | None | void | Minimizes the window |
+| `unMinimize()` | None | void | Restores the window (cancels minimize) |
+| `close()` | None | void | Closes the window and returns to pool |
+| `setTitle(title)` | `title`: string | void | Sets the window title |
+| `setDecorated(isDecorated)` | `isDecorated`: boolean | void | Sets whether the window has borders and title bar |
+| `resizable(resizable)` | `resizable`: boolean | void | Sets whether the window is resizable |
+| `setSize(width, height)` | `width`: number, `height`: number | void | Sets the window size in pixels |
+| `openDevTools()` | None | void | Opens developer tools |
+| `closeDevTools()` | None | void | Closes developer tools |
+| `id` | None | number | Unique window identifier, auto-incrementing |
 
 ## Development
 
@@ -381,4 +560,4 @@ pnpm run compile
 
 ## License
 
-MIT License
+MIT License

package/cli/index.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import build from './build.mjs';
+import help from './help.mjs';
+const args = process.argv.slice(2);
+if(args.length === 0) {
+    help();
+    process.exit(1);
+}
+if(args[0] === 'help') {
+    if(args.length > 1) {
+        help(args[1]);
+    } else {
+        help();
+    }
+}
+if(args[0] === 'build') {
+    build(args.slice(1));
+}

package/index.d.ts

@@ -1 +1 @@
-export * from './src/WindowManager.js';
+export * from './src/Application.js';

package/index.js

@@ -1 +1 @@
-export * from './src/WindowManager.js';
+export * from './src/Application.js';

package/package.json

@@ -6,6 +6,9 @@
   "bugs": {
     "url": "https://github.com/nexfteam/Nexfep/issues"
   },
+  "bin": {
+    "nexfep": "cli/index.mjs"
+  },
   "keywords": [
     "desktop",
     "application",
@@ -14,7 +17,7 @@
     "webview",
     "typescript"
   ],
-  "version": "0.1.7",
+  "version": "0.3.0",
   "type": "module",
   "main": "./index.js",
   "scripts": {
@@ -33,10 +36,14 @@
     "LICENSE",
     "package.json",
     "src/WindowManager.js",
-    "src/WindowManager.d.ts"
+    "src/WindowManager.d.ts",
+    "src/Application.js",
+    "src/Application.d.ts",
+    "src/Tray.js",
+    "src/Tray.d.ts"
   ],
   "dependencies": {
-    "@webviewjs/webview": "0.1.4"
+    "@webviewjs/webview": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/Application.d.ts

@@ -0,0 +1,30 @@
+import { Application as WebviewApplication, TrayIconImage, Notification } from '@webviewjs/webview';
+import { WindowPool } from './WindowManager.js';
+import { Tray } from './Tray.js';
+import { Logger } from './Logger.js';
+declare class __Utils {
+    app: WebviewApplication;
+    constructor(app: WebviewApplication);
+    notify(title: string, body?: string): Notification;
+}
+declare class Application {
+    app: WebviewApplication;
+    windows: WindowPool;
+    logger: Logger;
+    utils: __Utils;
+    constructor(options: {
+        WindowsWebview2UserDataFolder?: string;
+        LogFilePath?: string;
+    });
+    createTray(options: {
+        id: string;
+        tooltip: string;
+        icon: TrayIconImage | undefined;
+        menuItems: Array<{
+            id: string;
+            label: string;
+        }>;
+    }): Tray;
+    exit(): void;
+}
+export { Application };

package/src/Application.js

@@ -0,0 +1,35 @@
+import { Application as WebviewApplication, Notification } from '@webviewjs/webview';
+import { WindowPool } from './WindowManager.js';
+import { Tray } from './Tray.js';
+import { Logger } from './Logger.js';
+class __Utils {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    notify(title, body) {
+        const notification = new Notification(title, { body });
+        return notification;
+    }
+}
+class Application {
+    app;
+    windows;
+    logger;
+    utils;
+    constructor(options) {
+        this.app = new WebviewApplication();
+        this.utils = new __Utils(this.app);
+        this.logger = new Logger(options.LogFilePath);
+        const poolOptions = { WindowsWebview2UserDataFolder: options.WindowsWebview2UserDataFolder, logger: this.logger };
+        this.windows = new WindowPool(this.app, poolOptions);
+        this.app.whenReady();
+    }
+    createTray(options) {
+        return new Tray(this.app, options);
+    }
+    exit() {
+        this.app.exit();
+    }
+}
+export { Application };

package/src/Tray.d.ts

@@ -0,0 +1,36 @@
+import { Application, TrayIcon, TrayIconImage } from '@webviewjs/webview';
+declare class Tray {
+    app: Application;
+    tray: TrayIcon;
+    menuItems: Array<{
+        id: string;
+        label: string;
+    }>;
+    destroyed: boolean;
+    constructor(app: Application, options: {
+        id: string;
+        tooltip: string;
+        icon: TrayIconImage | undefined;
+        menuItems: Array<{
+            id: string;
+            label: string;
+        }>;
+    });
+    __ErrorWhenDestroyed(): void;
+    addMenuItem(item: {
+        id: string;
+        label: string;
+    }): void;
+    removeMenuItem(id: string): void;
+    setMenuItems(items: Array<{
+        id: string;
+        label: string;
+    }>): void;
+    setIcon(icon: Uint8Array<ArrayBuffer | SharedArrayBuffer> | number[], width?: number | null | undefined, height?: number | null | undefined): void;
+    on(event: string, callback: (event: any) => void): void;
+    setTooltip(tooltip: string): void;
+    hide(): void;
+    show(): void;
+    destroy(): void;
+}
+export { Tray };

package/src/Tray.js

@@ -0,0 +1,65 @@
+class Tray {
+    app;
+    tray;
+    menuItems;
+    destroyed;
+    constructor(app, options) {
+        this.menuItems = options.menuItems;
+        this.destroyed = false;
+        this.app = app;
+        this.tray = app.createTrayIcon({
+            id: options.id,
+            tooltip: options.tooltip,
+            icon: options.icon,
+            menu: {
+                items: this.menuItems
+            }
+        });
+    }
+    __ErrorWhenDestroyed() {
+        if (this.destroyed) {
+            throw new Error('Tray has been destroyed');
+        }
+    }
+    addMenuItem(item) {
+        this.__ErrorWhenDestroyed();
+        this.menuItems.push(item);
+        this.tray.setMenu({ items: this.menuItems });
+    }
+    removeMenuItem(id) {
+        this.__ErrorWhenDestroyed();
+        this.menuItems = this.menuItems.filter(item => item.id !== id);
+        this.tray.setMenu({ items: this.menuItems });
+    }
+    setMenuItems(items) {
+        this.__ErrorWhenDestroyed();
+        this.menuItems = items;
+        this.tray.setMenu({ items: this.menuItems });
+    }
+    setIcon(icon, width, height) {
+        this.__ErrorWhenDestroyed();
+        this.tray.setIcon(icon, width, height);
+    }
+    on(event, callback) {
+        this.__ErrorWhenDestroyed();
+        this.tray.on(event, callback);
+    }
+    setTooltip(tooltip) {
+        this.__ErrorWhenDestroyed();
+        this.tray.setTooltip(tooltip);
+    }
+    hide() {
+        this.__ErrorWhenDestroyed();
+        this.tray.setVisible(false);
+    }
+    show() {
+        this.__ErrorWhenDestroyed();
+        this.tray.setVisible(true);
+    }
+    destroy() {
+        this.__ErrorWhenDestroyed();
+        this.tray.dispose();
+        this.destroyed = true;
+    }
+}
+export { Tray };

package/src/WindowManager.d.ts

@@ -1,4 +1,5 @@
-import { BrowserWindow, Webview } from "@webviewjs/webview";
+import { Application, BrowserWindow, Webview } from "@webviewjs/webview";
+import { Logger } from "./Logger.js";
 declare class Window {
     window: BrowserWindow;
     webview: Webview;
@@ -17,6 +18,7 @@ declare class Window {
     unMinimize(): void;
     openDevTools(): void;
     closeDevTools(): void;
+    setSize(width: number, height: number): void;
     hide(): void;
     show(): void;
     close(): void;
@@ -25,22 +27,24 @@ declare class Window {
 }
 declare class WindowPool {
     onCustomMessage: (window: Window, data: string) => void;
-    private app;
+    app: Application;
+    logger: Logger;
     private windows;
     private handlers;
     private injectCount;
     private windowCount;
     private freeWindowCount;
     global: Map<string, any>;
-    constructor(WindowsWebview2UserDataFolder?: string);
+    constructor(app: Application, options: {
+        WindowsWebview2UserDataFolder?: string;
+        logger?: Logger;
+    });
     __injectCode(window: Window, code: string): Promise<void>;
     __injectControlFunctions(windowObj: Window): Promise<void>;
     __createNewWindowObj(): Promise<Window>;
     createWindow(isShow?: boolean, isDecorated?: boolean): Promise<Window>;
     closeWindow(window: Window): Promise<void>;
-    closePool(): Promise<void>;
     handle(event: string, callback: (data: any) => any): Promise<void>;
     unhandle(event: string, callback: (data: any) => any): Promise<void>;
-    mainloop(): void;
 }
 export { WindowPool, Window };

package/src/WindowManager.js

@@ -1,4 +1,4 @@
-import { Application } from "@webviewjs/webview";
+import { Logger } from "./Logger.js";
 import os from 'os';
 import path from 'path';
 import fs from 'fs';
@@ -47,6 +47,9 @@ class Window {
     closeDevTools() {
         this.webview.closeDevtools();
     }
+    setSize(width, height) {
+        this.window.setSize(width, height);
+    }
     hide() {
         this.window.hide();
         this.isShow = false;
@@ -70,16 +73,17 @@ class Window {
 class WindowPool {
     onCustomMessage;
     app;
+    logger;
     windows;
     handlers;
     injectCount;
     windowCount;
     freeWindowCount;
     global;
-    constructor(WindowsWebview2UserDataFolder = path.join(process.env.LOCALAPPDATA || os.homedir(), 'NexfepDevelopment.webview2-data')) {
+    constructor(app, options) {
         if (os.platform() === 'win32') {
             // 设置 WebView2 用户数据目录（仅 Windows 需要此配置）
-            const userDataDir = WindowsWebview2UserDataFolder;
+            const userDataDir = options.WindowsWebview2UserDataFolder || path.join(process.env.LOCALAPPDATA || os.homedir(), 'NexfepDevelopment.webview2-data');
             if (!fs.existsSync(userDataDir)) {
                 fs.mkdirSync(userDataDir, { recursive: true });
             }
@@ -89,12 +93,13 @@ class WindowPool {
             console.log('Get Custom Message:', data, "from window", window.id);
         };
         this.handlers = new Map();
-        this.app = new Application();
+        this.app = app;
         this.injectCount = 0;
         this.windows = [];
         this.windowCount = 0;
         this.freeWindowCount = 0;
         this.global = new Map();
+        this.logger = options.logger || new Logger();
     }
     async __injectCode(window, code) {
         await window.webview.evaluateScript(code);
@@ -233,6 +238,37 @@ class WindowPool {
             const MessageBody = { type: 'NexfepTell', to: to, message: message, data: data }
             window.ipc.postMessage(JSON.stringify(MessageBody));
         }
+
+        window.__originConsoleLog = console.log;
+        window.__originConsoleError = console.error;
+        window.__originConsoleInfo = console.info;
+        window.__originConsoleWarn = console.warn;
+        window.__originConsoleDebug = console.debug;
+        console.log = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleLog', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleLog(...args);
+        }
+        console.error = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleError', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleError(...args);
+        }
+        console.info = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleInfo', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleInfo(...args);
+        }
+        console.warn = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleWarn', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleWarn(...args);
+        }
+        console.debug = (...args) => {
+            const MessageBody = { type: 'NexfepConsoleDebug', message: args }
+            window.ipc.postMessage(JSON.stringify(MessageBody));
+            window.__originConsoleDebug(...args);
+        }
         
         // 注入 CSS 样式
         const style = document.createElement('style');
@@ -339,6 +375,21 @@ class WindowPool {
                     }
                 });
             }
+            else if (dataObj.type == 'NexfepConsoleLog') {
+                this.logger.__printLog(windowObj.id, 'Log', dataObj.message);
+            }
+            else if (dataObj.type == 'NexfepConsoleError') {
+                this.logger.__printLog(windowObj.id, 'Error', dataObj.message, '\x1b[31m', '\x1b[0m');
+            }
+            else if (dataObj.type == 'NexfepConsoleInfo') {
+                this.logger.__printLog(windowObj.id, 'Info', dataObj.message, '\x1b[34m', '\x1b[0m');
+            }
+            else if (dataObj.type == 'NexfepConsoleWarn') {
+                this.logger.__printLog(windowObj.id, 'Warn', dataObj.message, '\x1b[33m', '\x1b[0m');
+            }
+            else if (dataObj.type == 'NexfepConsoleDebug') {
+                this.logger.__printLog(windowObj.id, 'Debug', dataObj.message, '\x1b[90m', '\x1b[0m');
+            }
         });
         return windowObj;
     }
@@ -371,17 +422,11 @@ class WindowPool {
             throw new Error("Window is not open");
         }
     }
-    async closePool() {
-        this.app.exit();
-    }
     async handle(event, callback) {
         this.handlers.set(event, [...this.handlers.get(event) || [], callback]);
     }
     async unhandle(event, callback) {
         this.handlers.set(event, (this.handlers.get(event) || []).filter(c => c !== callback));
     }
-    mainloop() {
-        this.app.run();
-    }
 }
 export { WindowPool, Window };