@nocobase/plugin-flow-engine 2.1.0-alpha.9 → 2.1.0-beta.10

package/dist/ai/docs/runjs/context/libs.md

@@ -1,39 +1,39 @@
 # ctx.libs
 
-`ctx.libs` is the unified namespace for built-in libraries in RunJS, containing commonly used libraries such as React, Ant Design, dayjs, and lodash. **No `import` or asynchronous loading is required**; they can be used directly via `ctx.libs.xxx`.
+`ctx.libs` is the unified namespace for RunJS built-in libraries (React, Ant Design, dayjs, lodash, etc.). **No `import` or async loading**; use `ctx.libs.xxx` directly.
 
 ## Use Cases
 
 | Scenario | Description |
-|------|------|
-| **JSBlock / JSField / JSItem / JSColumn** | Use React + Ant Design to render UI, dayjs for date handling, and lodash for data processing. |
-| **Formula / Calculation** | Use formula or math for Excel-like formulas and mathematical expression operations. |
-| **Workflow / Linkage Rules** | Call utility libraries like lodash, dayjs, and formula in pure logic scenarios. |
+|----------|-------------|
+| **JSBlock / JSField / JSItem / JSColumn** | React + Ant Design for UI, dayjs for dates, lodash for data |
+| **Formulas / calculations** | formula or math for Excel-like formulas and math expressions |
+| **Event flow / linkage** | lodash, dayjs, formula, etc. in logic-only code |
 
-## Built-in Libraries Overview
+## Built-in libraries
 
-| Property | Description | Documentation |
-|------|------|------|
-| `ctx.libs.React` | React core, used for JSX and Hooks | [React](https://react.dev/) |
-| `ctx.libs.ReactDOM` | ReactDOM client API (including `createRoot`), used with React for rendering | [React DOM](https://react.dev/reference/react-dom) |
-| `ctx.libs.antd` | Ant Design component library (Button, Card, Table, Form, Input, Modal, etc.) | [Ant Design](https://ant.design/components/overview/) |
-| `ctx.libs.antdIcons` | Ant Design icon library (e.g., PlusOutlined, UserOutlined) | [@ant-design/icons](https://ant.design/components/icon/) |
-| `ctx.libs.dayjs` | Date and time utility library | [dayjs](https://day.js.org/) |
-| `ctx.libs.lodash` | Utility library (get, set, debounce, etc.) | [Lodash](https://lodash.com/docs/) |
-| `ctx.libs.formula` | Excel-like formula function library (SUM, AVERAGE, IF, etc.) | [Formula.js](https://formulajs.info/functions/) |
-| `ctx.libs.math` | Mathematical expression and calculation library | [Math.js](https://mathjs.org/docs/) |
+| Property | Description | Docs |
+|----------|-------------|------|
+| `ctx.libs.React` | React core for JSX and Hooks | [React](https://react.dev/) |
+| `ctx.libs.ReactDOM` | ReactDOM (e.g. `createRoot`) | [React DOM](https://react.dev/reference/react-dom) |
+| `ctx.libs.antd` | Ant Design (Button, Card, Table, Form, Input, Modal, etc.) | [Ant Design](https://ant.design/components/overview/) |
+| `ctx.libs.antdIcons` | Ant Design icons (PlusOutlined, UserOutlined, etc.) | [@ant-design/icons](https://ant.design/components/icon/) |
+| `ctx.libs.dayjs` | Date/time utilities | [dayjs](https://day.js.org/) |
+| `ctx.libs.lodash` | Utilities (get, set, debounce, etc.) | [Lodash](https://lodash.com/docs/) |
+| `ctx.libs.formula` | Excel-like formulas (SUM, AVERAGE, IF, etc.) | [Formula.js](https://formulajs.info/functions/) |
+| `ctx.libs.math` | Math expressions and evaluation | [Math.js](https://mathjs.org/docs/) |
 
-## Top-level Aliases
+## Top-level aliases
 
-For compatibility with legacy code, some libraries are also exposed at the top level: `ctx.React`, `ctx.ReactDOM`, `ctx.antd`, and `ctx.dayjs`. **It is recommended to consistently use `ctx.libs.xxx`** for easier maintenance and documentation searching.
+For backward compatibility, some libs are also on `ctx`: `ctx.React`, `ctx.ReactDOM`, `ctx.antd`, `ctx.dayjs`. **Prefer `ctx.libs.xxx`** for consistency and docs.
 
-## Lazy Loading
+## Lazy loading
 
-`lodash`, `formula`, and `math` use **lazy loading**: a dynamic import is triggered only when `ctx.libs.lodash` is accessed for the first time, and the cache is reused thereafter. `React`, `antd`, `dayjs`, and `antdIcons` are pre-configured by the context and are available immediately.
+`lodash`, `formula`, `math` are **lazy-loaded**: the first access to `ctx.libs.lodash` triggers a dynamic import, then the result is cached. `React`, `antd`, `dayjs`, `antdIcons` are preloaded in context.
 
 ## Examples
 
-### Rendering with React and Ant Design
+### React and Ant Design
 
 ```tsx
 const { Button, Card } = ctx.libs.antd;
@@ -45,7 +45,7 @@ ctx.render(
 );
 ```
 
-### Using Hooks
+### Hooks
 
 ```tsx
 const { React } = ctx.libs;
@@ -59,7 +59,7 @@ const App = () => {
 ctx.render(<App />);
 ```
 
-### Using Icons
+### Icons
 
 ```tsx
 const { Button } = ctx.libs.antd;
@@ -68,7 +68,7 @@ const { UserOutlined, HeartOutlined } = ctx.libs.antdIcons;
 ctx.render(<Button icon={<UserOutlined />}>User</Button>);
 ```
 
-### Date Processing with dayjs
+### dayjs
 
 ```ts
 const now = ctx.libs.dayjs();
@@ -76,14 +76,14 @@ const formatted = now.format('YYYY-MM-DD HH:mm:ss');
 ctx.message.info(formatted);
 ```
 
-### Utility Functions with lodash
+### lodash
 
 ```ts
 const user = { profile: { name: 'Alice' } };
 const name = ctx.libs.lodash.get(user, 'profile.name', 'Unknown');
 ```
 
-### Formula Calculations
+### formula
 
 ```ts
 const values = [1, 2, 3, 4];
@@ -91,7 +91,7 @@ const sum = ctx.libs.formula.SUM(values);
 const avg = ctx.libs.formula.AVERAGE(values);
 ```
 
-### Mathematical Expressions with math.js
+### math
 
 ```ts
 const result = ctx.libs.math.evaluate('2 + 3 * 4');
@@ -100,10 +100,10 @@ const result = ctx.libs.math.evaluate('2 + 3 * 4');
 
 ## Notes
 
-- **Mixing with ctx.importAsync**: If an external React is loaded via `ctx.importAsync('react@19')`, JSX will use that instance. In this case, **do not** mix it with `ctx.libs.antd`. Ant Design must be loaded to match that React version (e.g., `ctx.importAsync('antd@5.x')`, `ctx.importAsync('@ant-design/icons@5.x')`).
-- **Multiple React Instances**: If "Invalid hook call" occurs or the hook dispatcher is null, it is usually caused by multiple React instances. Before reading `ctx.libs.React` or calling Hooks, execute `await ctx.importAsync('react@version')` first to ensure the same React instance is shared with the page.
+- **Mixing with ctx.importAsync**: If you load external React via `ctx.importAsync('react@19')`, JSX uses that instance; **do not** mix with `ctx.libs.antd`. Load antd for that React version (e.g. `ctx.importAsync('antd@5.x')`, `ctx.importAsync('@ant-design/icons@5.x')`).
+- **Multiple React instances**: "Invalid hook call" or null hook dispatcher usually means multiple React instances. Before using `ctx.libs.React` or Hooks, run `await ctx.importAsync('react@version')` so the same React as the page is used.
 
 ## Related
 
-- [ctx.importAsync()](./import-async.md) - Load external ESM modules on demand (e.g., specific versions of React, Vue)
-- [ctx.render()](./render.md) - Render content to a container
+- [ctx.importAsync()](./import-async.md): load external ESM (e.g. specific React, Vue)
+- [ctx.render()](./render.md): render into container

package/dist/ai/docs/runjs/context/location.md

@@ -1,88 +1,85 @@
 # ctx.location
 
-Current route location information, equivalent to the React Router `location` object. It is typically used in conjunction with `ctx.router` and `ctx.route` to read the current path, query string, hash, and state passed through the route.
+Current route location, equivalent to React Router’s `location`. Use with `ctx.router` and `ctx.route` to read pathname, search, hash, and state passed via navigation.
 
 ## Use Cases
 
 | Scenario | Description |
-|------|------|
-| **JSBlock / JSField** | Perform conditional rendering or logic branching based on the current path, query parameters, or hash. |
-| **Linkage Rules / FlowEngine** | Read URL query parameters for linkage filtering, or determine the source based on `location.state`. |
-| **Post-navigation processing** | Receive data passed from the previous page via `ctx.router.navigate` using `ctx.location.state` on the target page. |
+|----------|-------------|
+| **JSBlock / JSField** | Conditional render or logic based on path, query, or hash |
+| **Linkage / event flow** | Read URL params for filtering or use `location.state` for source |
+| **After navigation** | On target page, read `ctx.location.state` from `ctx.router.navigate` |
 
-> Note: `ctx.location` is only available in RunJS environments with a routing context (e.g., JSBlock within a page, FlowEngine, etc.); it may be null in pure backend or non-routing contexts (e.g., Workflows).
+> Note: `ctx.location` is only available in RunJS when a router context exists (e.g. JSBlock on a page, event flow); in pure backend or non-routed contexts (e.g. workflow) it may be empty.
 
-## Type Definition
+## Type
 
 ```ts
 location: Location;
 ```
 
-`Location` comes from `react-router-dom`, consistent with the return value of React Router's `useLocation()`.
+`Location` is from `react-router-dom`, same as `useLocation()`.
 
 ## Common Fields
 
 | Field | Type | Description |
-|------|------|------|
-| `pathname` | `string` | The current path, starting with `/` (e.g., `/admin/users`). |
-| `search` | `string` | The query string, starting with `?` (e.g., `?page=1&status=active`). |
-| `hash` | `string` | The hash fragment, starting with `#` (e.g., `#section-1`). |
-| `state` | `any` | Arbitrary data passed via `ctx.router.navigate(path, { state })`, not reflected in the URL. |
-| `key` | `string` | A unique identifier for this location; the initial page is `"default"`. |
+|-------|------|-------------|
+| `pathname` | `string` | Current path, leading `/` (e.g. `/admin/users`) |
+| `search` | `string` | Query string, leading `?` (e.g. `?page=1&status=active`) |
+| `hash` | `string` | Hash fragment, leading `#` (e.g. `#section-1`) |
+| `state` | `any` | Data passed via `ctx.router.navigate(path, { state })`; not in URL |
+| `key` | `string` | Unique key for this location; initial page is `"default"` |
 
-## Relationship with ctx.router and ctx.urlSearchParams
+## Relation to ctx.router, ctx.urlSearchParams
 
-| Purpose | Recommended Usage |
-|------|----------|
-| **Read path, hash, state** | `ctx.location.pathname` / `ctx.location.hash` / `ctx.location.state` |
-| **Read query parameters (as object)** | `ctx.urlSearchParams`, which provides the parsed object directly. |
-| **Parse search string** | `new URLSearchParams(ctx.location.search)` or use `ctx.urlSearchParams` directly. |
+| Use | Recommended |
+|-----|-------------|
+| **Path, hash, state** | `ctx.location.pathname` / `ctx.location.hash` / `ctx.location.state` |
+| **Query params as object** | `ctx.urlSearchParams` |
+| **Parse search** | `new URLSearchParams(ctx.location.search)` or `ctx.urlSearchParams` |
 
-`ctx.urlSearchParams` is parsed from `ctx.location.search`. If you only need query parameters, using `ctx.urlSearchParams` is more convenient.
+`ctx.urlSearchParams` is derived from `ctx.location.search`; use it when you only need query params.
 
 ## Examples
 
-### Branching Based on Path
+### Branch by path
 
 ```ts
 if (ctx.location.pathname.startsWith('/admin/users')) {
-  ctx.message.info('Currently on the user management page');
+  ctx.message.info('On user management page');
 }
 ```
 
-### Parsing Query Parameters
+### Parse query params
 
 ```ts
-// Method 1: Using ctx.urlSearchParams (Recommended)
 const page = ctx.urlSearchParams.page || 1;
 const status = ctx.urlSearchParams.status;
 
-// Method 2: Using URLSearchParams to parse search
 const params = new URLSearchParams(ctx.location.search);
 const page = params.get('page') || '1';
 const status = params.get('status');
 ```
 
-### Receiving State Passed via Route Navigation
+### Read state from navigation
 
 ```ts
-// When navigating from the previous page: ctx.router.navigate('/users/123', { state: { from: 'dashboard' } })
 const prevState = ctx.location.state;
 if (prevState?.from === 'dashboard') {
-  ctx.message.info('Navigated from the dashboard');
+  ctx.message.info('Navigated from dashboard');
 }
 ```
 
-### Locating Anchors via Hash
+### Anchor by hash
 
 ```ts
-const hash = ctx.location.hash; // e.g., "#edit"
+const hash = ctx.location.hash;
 if (hash === '#edit') {
-  // Scroll to the edit area or execute corresponding logic
+  // Scroll to edit or run logic
 }
 ```
 
 ## Related
 
-- [ctx.router](./router.md): Route navigation; the `state` from `ctx.router.navigate` can be retrieved via `ctx.location.state` on the target page.
-- [ctx.route](./route.md): Current route match information (parameters, configuration, etc.), often used in conjunction with `ctx.location`.
+- [ctx.router](./router.md): navigation; `state` from `ctx.router.navigate` is available as `ctx.location.state`
+- [ctx.route](./route.md): current route match (params, config); use with `ctx.location`

package/dist/ai/docs/runjs/context/logger.md

@@ -1,85 +1,84 @@
 # ctx.logger
 
-A logging wrapper based on [pino](https://github.com/pinojs/pino), providing high-performance structured JSON logs. It is recommended to use `ctx.logger` instead of `console` for easier log collection and analysis.
+Logging built on [pino](https://github.com/pinojs/pino); outputs structured JSON. Prefer `ctx.logger` over `console` for collection and analysis.
 
-## Scenarios
+## Use Cases
 
-`ctx.logger` can be used in all RunJS scenarios for debugging, error tracking, performance analysis, etc.
+Available in all RunJS contexts for debugging, error tracking, and performance.
 
-## Type Definition
+## Type
 
 ```ts
 logger: pino.Logger;
 ```
 
-`ctx.logger` is an instance of `engine.logger.child({ module: 'flow-engine' })`, which is a pino child logger with a `module` context.
+`ctx.logger` is `engine.logger.child({ module: 'flow-engine' })`, i.e. a pino child logger with a `module` context.
 
-## Log Levels
+## Log levels
 
-pino supports the following levels (from highest to lowest):
+From highest to lowest:
 
 | Level | Method | Description |
-|------|------|------|
-| `fatal` | `ctx.logger.fatal()` | Fatal error, usually leading to process exit |
-| `error` | `ctx.logger.error()` | Error, indicating a failed request or operation |
-| `warn` | `ctx.logger.warn()` | Warning, indicating potential risks or abnormal situations |
-| `info` | `ctx.logger.info()` | General runtime information |
-| `debug` | `ctx.logger.debug()` | Debugging information, used during development |
-| `trace` | `ctx.logger.trace()` | Detailed trace, used for deep diagnostics |
+|-------|--------|-------------|
+| `fatal` | `ctx.logger.fatal()` | Fatal; usually process exit |
+| `error` | `ctx.logger.error()` | Error; request or operation failed |
+| `warn` | `ctx.logger.warn()` | Warning; potential issue |
+| `info` | `ctx.logger.info()` | General runtime info |
+| `debug` | `ctx.logger.debug()` | Debug; development |
+| `trace` | `ctx.logger.trace()` | Verbose; deep diagnosis |
 
-## Recommended Usage
+## Recommended usage
 
-The recommended format is `level(msg, meta)`: the message comes first, followed by an optional metadata object.
+Use `level(msg, meta)`: message first, optional metadata object second.
 
 ```ts
-ctx.logger.info('Block loading complete');
-ctx.logger.info('Operation successful', { recordId: 456 });
-ctx.logger.warn('Performance warning', { duration: 5000 });
-ctx.logger.error('Operation failed', { userId: 123, action: 'create' });
+ctx.logger.info('Block loaded');
+ctx.logger.info('Success', { recordId: 456 });
+ctx.logger.warn('Slow', { duration: 5000 });
+ctx.logger.error('Failed', { userId: 123, action: 'create' });
 ctx.logger.error('Request failed', { err });
 ```
 
-pino also supports `level(meta, msg)` (object first) or `level({ msg, ...meta })` (single object), which can be used as needed.
+pino also supports `level(meta, msg)` or `level({ msg, ...meta })` if needed.
 
 ## Examples
 
-### Basic Usage
+### Basic
 
 ```ts
-ctx.logger.info('Block loading complete');
+ctx.logger.info('Block loaded');
 ctx.logger.warn('Request failed, using cache', { err });
-ctx.logger.debug('Saving...', { recordId: ctx.record?.id });
+ctx.logger.debug('Saving', { recordId: ctx.record?.id });
 ```
 
-### Creating a Child Logger with child()
+### Child logger
 
 ```ts
-// Create a child logger with context for the current logic
 const log = ctx.logger.child({ scope: 'myBlock' });
-log.info('Executing step 1');
-log.debug('Executing step 2', { step: 2 });
+log.info('Step 1');
+log.debug('Step 2', { step: 2 });
 ```
 
-### Relationship with console
+### vs console
 
-It is recommended to use `ctx.logger` directly to obtain structured JSON logs. If you are accustomed to using `console`, the mappings are: `console.log` → `ctx.logger.info`, `console.error` → `ctx.logger.error`, `console.warn` → `ctx.logger.warn`.
+Prefer `ctx.logger` for structured JSON. Rough mapping: `console.log` → `ctx.logger.info`, `console.error` → `ctx.logger.error`, `console.warn` → `ctx.logger.warn`.
 
-## Log Format
+## Output format
 
-pino outputs structured JSON, where each log entry contains:
+pino outputs JSON with:
 
-- `level`: Log level (numeric)
-- `time`: Timestamp (milliseconds)
-- `msg`: Log message
-- `module`: Fixed as `flow-engine`
-- Other custom fields (passed via objects)
+- `level`: numeric level
+- `time`: timestamp (ms)
+- `msg`: message
+- `module`: `flow-engine`
+- Any custom fields passed in the object
 
 ## Notes
 
-- Logs are structured JSON, making them easy to collect, search, and analyze.
-- Child loggers created via `child()` also follow the `level(msg, meta)` recommendation.
-- Some runtime environments (such as Workflows) may use different log output methods.
+- Logs are JSON for easy collection and querying
+- Child loggers from `child()` also work well with `level(msg, meta)`
+- Some environments (e.g. workflow) may use different log handling
 
 ## Related
 
-- [pino](https://github.com/pinojs/pino) — The underlying logging library
+- [pino](https://github.com/pinojs/pino)

package/dist/ai/docs/runjs/context/make-resource.md

@@ -1,18 +1,18 @@
 # ctx.makeResource()
 
-**Creates** and returns a new resource instance **without** writing to or modifying `ctx.resource`. It is suitable for scenarios requiring multiple independent resources or temporary usage.
+**Creates** a new resource instance and returns it; **does not** set or change `ctx.resource`. Use when you need multiple resources or a temporary one.
 
 ## Use Cases
 
 | Scenario | Description |
-|------|------|
-| **Multiple resources** | Load multiple data sources simultaneously (e.g., user list + order list), each using an independent resource. |
-| **Temporary queries** | One-time queries that are discarded after use, without needing to bind to `ctx.resource`. |
-| **Auxiliary data** | Use `ctx.resource` for primary data and `makeResource` to create instances for additional data. |
+|----------|-------------|
+| **Multiple resources** | Load several data sources (e.g. users + orders), each with its own resource |
+| **One-off query** | Single query, no need to bind to `ctx.resource` |
+| **Auxiliary data** | Main data in `ctx.resource`, extra data from a `makeResource` instance |
 
-If you only need a single resource and want to bind it to `ctx.resource`, using [ctx.initResource()](./init-resource.md) is more appropriate.
+If you only need one resource and want it on `ctx.resource`, use [ctx.initResource()](./init-resource.md).
 
-## Type Definition
+## Type
 
 ```ts
 makeResource<T = FlowResource>(
@@ -21,17 +21,17 @@ makeResource<T = FlowResource>(
 ```
 
 | Parameter | Type | Description |
-|------|------|------|
-| `resourceType` | `string` | Resource type: `'APIResource'`, `'SingleRecordResource'`, `'MultiRecordResource'`, `'SQLResource'` |
+|-----------|------|-------------|
+| `resourceType` | `string` | `'APIResource'`, `'SingleRecordResource'`, `'MultiRecordResource'`, `'SQLResource'` |
 
-**Returns**: The newly created resource instance.
+**Returns**: The new resource instance.
 
-## Difference from ctx.initResource()
+## Relation to ctx.initResource()
 
 | Method | Behavior |
-|------|------|
-| `ctx.makeResource(type)` | Only creates and returns a new instance, **not** writing to `ctx.resource`. Can be called multiple times to obtain multiple independent resources. |
-| `ctx.initResource(type)` | Creates and binds if `ctx.resource` does not exist; returns it directly if it already exists. Ensures `ctx.resource` is available. |
+|--------|----------|
+| `ctx.makeResource(type)` | Creates and returns; **does not** set `ctx.resource`; can call multiple times for multiple resources |
+| `ctx.initResource(type)` | Creates and binds if missing; otherwise returns existing. Ensures `ctx.resource` is set |
 
 ## Examples
 
@@ -42,7 +42,7 @@ const listRes = ctx.makeResource('MultiRecordResource');
 listRes.setResourceName('users');
 await listRes.refresh();
 const users = listRes.getData();
-// ctx.resource remains its original value (if any)
+// ctx.resource unchanged (if it existed)
 ```
 
 ### Multiple resources
@@ -58,16 +58,15 @@ await ordersRes.refresh();
 
 ctx.render(
   <div>
-    <p>User count: {usersRes.getData().length}</p>
-    <p>Order count: {ordersRes.getData().length}</p>
+    <p>Users: {usersRes.getData().length}</p>
+    <p>Orders: {ordersRes.getData().length}</p>
   </div>
 );
 ```
 
-### Temporary query
+### One-off query
 
 ```ts
-// One-time query, does not pollute ctx.resource
 const tempRes = ctx.makeResource('SingleRecordResource');
 tempRes.setResourceName('users');
 tempRes.setFilterByTk(1);
@@ -77,14 +76,14 @@ const record = tempRes.getData();
 
 ## Notes
 
-- The newly created resource needs to call `setResourceName(name)` to specify the collection, and then load data via `refresh()`.
-- Each resource instance is independent and does not affect others; suitable for loading multiple data sources in parallel.
+- Call `setResourceName(name)` then `refresh()` to load data.
+- Each instance is independent; good for loading several sources in parallel.
 
 ## Related
 
-- [ctx.initResource()](./init-resource.md): Initialize and bind to `ctx.resource`
-- [ctx.resource](./resource.md): The resource instance in the current context
-- [MultiRecordResource](../resource/multi-record-resource) — Multiple records/List
-- [SingleRecordResource](../resource/single-record-resource) — Single record
-- [APIResource](../resource/api-resource) — General API resource
-- [SQLResource](../resource/sql-resource) — SQL query resource
+- [ctx.initResource()](./init-resource.md): init and bind to `ctx.resource`
+- [ctx.resource](./resource.md): current context resource
+- [MultiRecordResource](../resource/multi-record-resource.md)
+- [SingleRecordResource](../resource/single-record-resource.md)
+- [APIResource](../resource/api-resource.md)
+- [SQLResource](../resource/sql-resource.md)

package/dist/ai/docs/runjs/context/message.md

@@ -1,63 +1,63 @@
 # ctx.message
 
-Ant Design global message API, used to display temporary light prompts at the top center of the page. Messages close automatically after a certain period or can be closed manually by the user.
+Ant Design global message API; shows short messages at the top center. Messages auto-close after a while or can be closed by the user.
 
 ## Use Cases
 
 | Scenario | Description |
-|------|------|
-| **JSBlock / JSField / JSItem / JSColumn** | Operation feedback, validation prompts, copy success, and other light prompts |
-| **Form Operations / Workflow** | Feedback for submission success, save failure, validation failure, etc. |
-| **Action Events (JSAction)** | Immediate feedback for clicks, batch operation completion, etc. |
+|----------|-------------|
+| **JSBlock / JSField / JSItem / JSColumn** | Quick feedback: validation, copy success, etc. |
+| **Form actions / event flow** | Submit success, save failed, validation failed |
+| **JSAction** | Click or batch action feedback |
 
-## Type Definition
+## Type
 
 ```ts
 message: MessageInstance;
 ```
 
-`MessageInstance` is the Ant Design message interface, providing the following methods.
+`MessageInstance` is the Ant Design message API.
 
 ## Common Methods
 
 | Method | Description |
-|------|------|
-| `success(content, duration?)` | Display a success prompt |
-| `error(content, duration?)` | Display an error prompt |
-| `warning(content, duration?)` | Display a warning prompt |
-| `info(content, duration?)` | Display an information prompt |
-| `loading(content, duration?)` | Display a loading prompt (must be closed manually) |
-| `open(config)` | Open a message using custom configuration |
-| `destroy()` | Close all currently displayed messages |
+|--------|-------------|
+| `success(content, duration?)` | Success message |
+| `error(content, duration?)` | Error message |
+| `warning(content, duration?)` | Warning message |
+| `info(content, duration?)` | Info message |
+| `loading(content, duration?)` | Loading (usually closed manually) |
+| `open(config)` | Open with custom config |
+| `destroy()` | Close all messages |
 
 **Parameters:**
 
-- `content` (`string` | `ConfigOptions`): Message content or configuration object
-- `duration` (`number`, optional): Auto-close delay (seconds), default is 3 seconds; set to 0 to disable auto-close
+- `content`: `string` or `ConfigOptions`
+- `duration`: optional seconds; default 3; 0 = no auto-close
 
-**ConfigOptions** (when `content` is an object):
+**ConfigOptions** (when content is an object):
 
 ```ts
 interface ConfigOptions {
-  content: React.ReactNode;  // Message content
-  duration?: number;        // Auto-close delay (seconds)
-  onClose?: () => void;    // Callback when closed
-  icon?: React.ReactNode;  // Custom icon
+  content: React.ReactNode;
+  duration?: number;
+  onClose?: () => void;
+  icon?: React.ReactNode;
 }
 ```
 
 ## Examples
 
-### Basic Usage
+### Basic
 
 ```ts
-ctx.message.success('Operation successful');
-ctx.message.error('Operation failed');
+ctx.message.success('Done');
+ctx.message.error('Failed');
 ctx.message.warning('Please select data first');
 ctx.message.info('Processing...');
 ```
 
-### Internationalization with ctx.t
+### With ctx.t (i18n)
 
 ```ts
 ctx.message.success(ctx.t('Copied'));
@@ -65,43 +65,42 @@ ctx.message.warning(ctx.t('Please select at least one row'));
 ctx.message.success(ctx.t('Exported {{count}} records', { count: rows.length }));
 ```
 
-### Loading and Manual Close
+### Loading and manual close
 
 ```ts
 const hide = ctx.message.loading(ctx.t('Saving...'));
-// Execute asynchronous operation
 await saveData();
-hide();  // Manually close loading
+hide();
 ctx.message.success(ctx.t('Saved'));
 ```
 
-### Custom Configuration with open
+### open with config
 
 ```ts
 ctx.message.open({
   type: 'success',
-  content: 'Custom success prompt',
+  content: 'Custom success',
   duration: 5,
-  onClose: () => console.log('message closed'),
+  onClose: () => console.log('closed'),
 });
 ```
 
-### Close All Messages
+### Close all
 
 ```ts
 ctx.message.destroy();
 ```
 
-## Difference Between ctx.message and ctx.notification
+## ctx.message vs ctx.notification
 
-| Feature | ctx.message | ctx.notification |
-|------|--------------|------------------|
-| **Position** | Top center of the page | Top right corner |
-| **Purpose** | Temporary light prompt, disappears automatically | Notification panel, can include title and description, suitable for longer display |
-| **Typical Scenarios** | Operation feedback, validation prompts, copy success | Task completion notifications, system messages, longer content requiring user attention |
+| | ctx.message | ctx.notification |
+|---|-------------|-------------------|
+| **Position** | Top center | Top right |
+| **Use** | Short, auto-dismiss | Panel with title/description; can stay longer |
+| **Typical** | Action feedback, validation, copy | Task done, system notice, longer content |
 
 ## Related
 
-- [ctx.notification](./notification.md) - Top-right notifications, suitable for longer display durations
-- [ctx.modal](./modal.md) - Modal confirmation, blocking interaction
-- [ctx.t()](./t.md) - Internationalization, commonly used with message
+- [ctx.notification](./notification.md): top-right notifications
+- [ctx.modal](./modal.md): modal confirm
+- [ctx.t()](./t.md): i18n; often used with message