zentao-api 0.3.2 → 0.4.0

package/dist/modules/resolve.js

@@ -1,5 +1,5 @@
 import { ZentaoError } from '../misc/errors.js';
-import { getNestedValue, isRecord } from '../utils/index.js';
+import { getNestedValue, isBlank, isRecord } from '../utils/index.js';
 import { getModuleAction } from './registry.js';
 const SCOPE_MAP = {
     product: 'products',
@@ -11,7 +11,7 @@ const SCOPE_KEY_ORDER = ['execution', 'project', 'product'];
 function pickScope(params) {
     for (const key of SCOPE_KEY_ORDER) {
         const value = params[key] ?? params[`${key}ID`];
-        if (value === undefined || value === null || value === '')
+        if (isBlank(value))
             continue;
         const numberValue = Number(value);
         if (!Number.isNaN(numberValue)) {
@@ -24,7 +24,7 @@ function pickScope(params) {
 function resolvePath(action, values) {
     return action.path.replace(/\{(\w+)\}/g, (_, key) => {
         const value = values[key];
-        if (value === undefined || value === '') {
+        if (isBlank(value)) {
             throw new ZentaoError('E_MISSING_PARAM', { param: key });
         }
         return String(value);
@@ -37,18 +37,21 @@ function parseData(value) {
     if (typeof value === 'string') {
         try {
             const parsed = JSON.parse(value);
-            return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : undefined;
+            return isRecord(parsed) ? parsed : undefined;
         }
         catch {
             return undefined;
         }
     }
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+    return isRecord(value) ? value : undefined;
 }
 const TRUTHY_STRINGS = new Set(['true', '1', 'yes', 'on']);
 const FALSY_STRINGS = new Set(['false', '0', 'no', 'off']);
-/** 按 OpenAPI schema 的基础类型对参数做轻量转换。 */
-function coerceValue(value, type, paramName) {
+/**
+ * 按 OpenAPI schema 的基础类型对参数做轻量转换。
+ * @param fromData 值是否来自 `params.data`（影响数组字段是否包装对象）。
+ */
+function coerceValue(value, type, paramName, fromData = false) {
     if (value === undefined || value === null)
         return value;
     if (type === 'number' || type === 'integer') {
@@ -75,50 +78,64 @@ function coerceValue(value, type, paramName) {
         }
         throw new ZentaoError('E_INVALID_PARAM', { param: paramName, value: String(value) });
     }
+    if (type === 'array') {
+        if (Array.isArray(value))
+            return value;
+        if (typeof value === 'string')
+            return value.split(',');
+        // 来自 params.data 的对象按原样保留，不强行包成单元素数组。
+        if (fromData && isRecord(value))
+            return value;
+        return [value];
+    }
     return value;
 }
-/** 将模块名、动作名和调用参数解析为实际 API 请求路径、查询参数和请求体。 */
-export function resolveModuleCommand(module, actionName, params = {}) {
-    const action = getModuleAction(module.name, actionName);
-    const pathValues = {};
+/** 解析路径占位符的取值：scope 列表前缀、对象 ID，以及默认值补齐。 */
+function resolvePathValues(module, action, params) {
+    const values = {};
     const pathParamNames = Object.keys(action.pathParams ?? {});
     // 生成定义中的 scope 列表接口会统一成 /{scope}/{scopeID}/xxx。
     if (pathParamNames.includes('scope')) {
         const scope = pickScope(params);
         if (!scope)
             throw new ZentaoError('E_MISSING_PARAM', { param: 'product/project/execution' });
-        pathValues.scope = scope.scope;
-        pathValues.scopeID = scope.scopeID;
+        values.scope = scope.scope;
+        values.scopeID = scope.scopeID;
     }
+    // 对象 ID 可来自 `id`、`{module}ID` 或路径中的 `xxxID` 占位符。
     const idParamName = pathParamNames.find((key) => key.endsWith('ID') && key !== 'scopeID');
     const idValue = params.id ?? params[`${module.name}ID`] ?? (idParamName ? params[idParamName] : undefined);
-    const id = idValue === undefined ? undefined : Number(idValue);
-    if (idParamName && id !== undefined && !Number.isNaN(id)) {
-        pathValues[idParamName] = id;
+    const idNumber = idValue === undefined ? Number.NaN : Number(idValue);
+    const id = Number.isNaN(idNumber) ? undefined : idNumber;
+    if (idParamName && id !== undefined) {
+        values[idParamName] = id;
     }
     // pathParams 中未显式传值的参数，可从定义里的默认值或第一个可选项补齐。
     for (const key of pathParamNames) {
-        if (key === 'scope' || key === 'scopeID' || pathValues[key] !== undefined)
+        if (key === 'scope' || key === 'scopeID' || values[key] !== undefined)
             continue;
         const definition = action.pathParams?.[key];
         const value = params[key];
         if (value !== undefined) {
-            pathValues[key] = value;
+            values[key] = value;
             continue;
         }
         if (typeof definition === 'object') {
             if (definition.defaultValue !== undefined) {
-                pathValues[key] = definition.defaultValue;
+                values[key] = definition.defaultValue;
             }
             else if (definition.options?.[0]?.value !== undefined) {
-                pathValues[key] = definition.options[0].value;
+                values[key] = definition.options[0].value;
             }
         }
-        if (pathValues[key] === undefined) {
+        if (values[key] === undefined) {
             throw new ZentaoError('E_MISSING_PARAM', { param: key });
         }
     }
-    // 查询参数只从 action.params 中声明过的字段生成，避免把 body 字段误放到 URL 上。
+    return { values, id };
+}
+/** 仅从 action.params 中声明过的字段生成查询参数，避免把 body 字段误放到 URL 上。 */
+function buildQuery(action, params) {
     const query = {};
     for (const param of action.params ?? []) {
         let value = params[param.name];
@@ -135,70 +152,72 @@ export function resolveModuleCommand(module, actionName, params = {}) {
             query[param.name] = value;
         }
     }
-    let data = parseData(params.data);
-    if (action.requestBody?.schema?.type === 'object') {
-        data = data ? { ...data } : {};
-        const schema = action.requestBody.schema;
-        const required = new Set(schema.required ?? []);
-        for (const [key, property] of Object.entries(schema.properties ?? {})) {
-            // body 字段优先级：params.data 中的字段 > 平铺 params 字段 > schema 默认值。
-            const hasDataValue = Object.prototype.hasOwnProperty.call(data, key);
-            const hasParamValue = Object.prototype.hasOwnProperty.call(params, key);
-            let value = hasDataValue ? data[key] : hasParamValue ? params[key] : property.defaultValue;
-            if (value === undefined && (property.required || required.has(key))) {
-                throw new ZentaoError('E_MISSING_PARAM', { param: key });
-            }
-            value = coerceValue(value, property.type, key);
-            if (property.type === 'array' && value !== undefined && value !== null && !Array.isArray(value)) {
-                if (typeof value === 'string') {
-                    value = value.split(',');
-                }
-                else if (!hasDataValue || !isRecord(value)) {
-                    value = [value];
-                }
-            }
-            if (value !== undefined) {
-                data[key] = value;
-            }
+    return query;
+}
+/** 按 requestBody schema 组装请求体，并对各字段做取值优先级解析与类型转换。 */
+function buildRequestBody(action, params) {
+    const base = parseData(params.data);
+    if (action.requestBody?.schema?.type !== 'object')
+        return base;
+    const data = base ? { ...base } : {};
+    const schema = action.requestBody.schema;
+    const required = new Set(schema.required ?? []);
+    for (const [key, property] of Object.entries(schema.properties ?? {})) {
+        // body 字段优先级：params.data 中的字段 > 平铺 params 字段 > schema 默认值。
+        const hasDataValue = Object.prototype.hasOwnProperty.call(data, key);
+        const hasParamValue = Object.prototype.hasOwnProperty.call(params, key);
+        const raw = hasDataValue ? data[key] : hasParamValue ? params[key] : property.defaultValue;
+        if (raw === undefined && (property.required || required.has(key))) {
+            throw new ZentaoError('E_MISSING_PARAM', { param: key });
+        }
+        const value = coerceValue(raw, property.type, key, hasDataValue);
+        if (value !== undefined) {
+            data[key] = value;
         }
     }
+    return data;
+}
+/** 将模块名、动作名和调用参数解析为实际 API 请求路径、查询参数和请求体。 */
+export function resolveActionRequest(module, actionName, params = {}) {
+    const action = getModuleAction(module.name, actionName);
+    const { values, id } = resolvePathValues(module, action, params);
     return {
         module: module.name,
         action,
         params,
-        path: resolvePath(action, pathValues),
-        query,
-        data,
-        id: id === undefined || Number.isNaN(id) ? undefined : id,
+        path: resolvePath(action, values),
+        query: buildQuery(action, params),
+        data: buildRequestBody(action, params),
+        id,
     };
 }
 /** 根据动作定义中的 resultGetter，从原始响应里提取业务数据。 */
-export function extractResult(action, response) {
+export function extractResult(action, response, params = {}) {
     const getter = action.resultGetter;
     if (!getter)
         return response.data ?? response;
     if (typeof getter === 'function')
-        return getter(response, {});
+        return getter(response, params);
     if (typeof getter === 'string')
         return getNestedValue(response, getter);
     const result = {};
     for (const [targetKey, sourceKey] of Object.entries(getter)) {
-        result[targetKey] = response[sourceKey];
+        result[targetKey] = getNestedValue(response, sourceKey);
     }
     return result;
 }
 /** 根据动作定义中的 pagerGetter，从原始响应里提取分页信息。 */
-export function extractPager(action, response) {
+export function extractPager(action, response, params = {}) {
     const getter = action.pagerGetter;
     if (!getter)
         return response.pager;
     if (typeof getter === 'function')
-        return getter(response, {});
+        return getter(response, params);
     if (typeof getter === 'string')
         return getNestedValue(response, getter);
-    const page = response[getter.pageID];
-    const recPerPage = response[getter.recPerPage];
-    const recTotal = response[getter.recTotal];
+    const page = getNestedValue(response, getter.pageID);
+    const recPerPage = getNestedValue(response, getter.recPerPage);
+    const recTotal = getNestedValue(response, getter.recTotal);
     if (page === undefined || recPerPage === undefined || recTotal === undefined)
         return undefined;
     return {

package/dist/request/index.d.ts

@@ -104,6 +104,9 @@ export type RequestResultFor<Name extends BuiltinRequestName> = ActionOfRequest<
  * 当响应 `status` 为 `"fail"` 时，默认按原样返回；若 `options.throwOnFail`
  * 或全局 `throwOnFail` 为真，则改为抛出 `E_API_FAILED`。
  *
+ * 对 `update` 动作，当 `options.autoFill` 或全局 `autoFill` 为真时，会先 GET 当前对象，
+ * 用现值补齐用户未显式传入的 body 字段后再 PUT，避免禅道覆盖未提交字段。详见 {@link RequestOptions.autoFill}。
+ *
  * @typeParam T 期望的 `data` 字段类型；不传时为 `unknown`，调用方需要自行收窄。
  * @param name - 请求名，例如 `product`、`product/list` 或 `product/1`。
  * @param params - 请求参数。

package/dist/request/index.js

@@ -1,7 +1,7 @@
 import { ZentaoError } from '../misc/errors.js';
 import { getGlobalOptions } from '../misc/global-options.js';
-import { getModule } from '../modules/registry.js';
-import { extractPager, extractResult, resolveModuleCommand } from '../modules/resolve.js';
+import { getModule, getModuleAction } from '../modules/registry.js';
+import { extractPager, extractResult, resolveActionRequest } from '../modules/resolve.js';
 import { isRecord, processData } from '../utils/index.js';
 /** 将 `moduleName`、`moduleName/methodName` 或 `moduleName/<objectID>` 请求名拆成模块名、动作名和对象 ID。 */
 function splitRequestName(name) {
@@ -30,6 +30,55 @@ function splitRequestName(name) {
         actionName,
     };
 }
+/** 解析 `params.data` 中用户显式传入的 body 字段名，用于 autoFill 判断字段归属。 */
+function getExplicitDataKeys(data) {
+    let value = data;
+    if (typeof value === 'string') {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return new Set();
+        }
+    }
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return new Set(Object.keys(value));
+    }
+    return new Set();
+}
+/**
+ * 在执行 `update` 动作前，用当前对象的现值填充用户未显式传入的 body 字段。
+ *
+ * 仅当模块存在 `type: 'get'` 动作且 update 动作声明了对象类型 body schema 时生效；
+ * 否则原样返回参数。GET 返回失败状态时会抛出 `E_API_FAILED`，避免继续发送未补齐的 PUT；
+ * GET 成功但返回非对象时跳过填充，交由后续 PUT 正常处理。
+ *
+ * 字段归属判断同时覆盖平铺 `params` 字段与 `params.data` 中的字段；只有 schema 中声明、
+ * 用户未传且当前对象存在的字段才会被补齐，避免覆盖用户本次想修改的字段。
+ */
+async function autoFillUpdateParams(module, action, params, options) {
+    const properties = action.requestBody?.schema?.properties;
+    const getAction = module.actions.find((candidate) => candidate.type === 'get');
+    if (!properties || !getAction)
+        return params;
+    const current = (await request(`${module.name}/${getAction.name}`, params, {
+        client: options.client,
+        timeout: options.timeout,
+        insecure: options.insecure,
+        throwOnFail: true,
+    })).data;
+    if (!isRecord(current))
+        return params;
+    const explicitDataKeys = getExplicitDataKeys(params.data);
+    const filled = { ...params };
+    for (const key of Object.keys(properties)) {
+        const userProvided = Object.prototype.hasOwnProperty.call(params, key) || explicitDataKeys.has(key);
+        if (!userProvided && Object.prototype.hasOwnProperty.call(current, key)) {
+            filled[key] = current[key];
+        }
+    }
+    return filled;
+}
 function stringifyMessage(value) {
     if (typeof value === 'string')
         return value;
@@ -96,9 +145,9 @@ function normalizeResponse(command, raw, options) {
     }
     const record = raw;
     const status = record.status === 'fail' ? 'fail' : 'success';
-    const data = applyProcessing(extractResult(command.action, record), options);
+    const data = applyProcessing(extractResult(command.action, record, command.params), options);
     const rawMessage = record.message;
-    const pager = extractPager(command.action, record);
+    const pager = extractPager(command.action, record, command.params);
     const response = {
         status,
         message: stringifyMessage(rawMessage),
@@ -134,7 +183,13 @@ export async function request(name, params = {}, options = {}) {
         ...(id !== undefined ? { id } : {}),
         ...(recPerPage !== undefined ? { recPerPage } : {}),
     };
-    const command = resolveModuleCommand(module, actionName, mergedParams);
+    // autoFill：update 动作先 GET 当前对象，用现值补齐用户未显式传入的字段，
+    // 避免禅道 PUT 把未提交字段覆盖为空。
+    const action = getModuleAction(moduleName, actionName);
+    const finalParams = action.type === 'update' && (options.autoFill ?? globals.autoFill)
+        ? await autoFillUpdateParams(module, action, mergedParams, options)
+        : mergedParams;
+    const command = resolveActionRequest(module, actionName, finalParams);
     const raw = await client.request(command.path, {
         method: String(command.action.method).toUpperCase(),
         query: command.query,
@@ -142,6 +197,9 @@ export async function request(name, params = {}, options = {}) {
         timeout: options.timeout ?? globals.timeout,
         insecure: options.insecure ?? globals.insecure,
     });
+    if (options.raw) {
+        return raw;
+    }
     // limit 现归入本地处理选项；本次调用优先，缺省回落到全局默认。
     const processOptions = { ...options, limit: options.limit ?? globals.limit };
     const response = normalizeResponse(command, raw, processOptions);

package/dist/types/module.d.ts

@@ -11,10 +11,14 @@ export type ModuleActionParamOption = {
     readonly value: unknown;
     readonly label: string;
 };
+/** 模块动作参数角色。 */
+export type ModuleActionParamRole = 'query' | 'path' | 'body';
 /** 模块动作的查询参数定义。 */
 export interface ModuleActionParam {
     /** 参数名称。 */
     name: string;
+    /** 参数角色。 */
+    role?: ModuleActionParamRole;
     /** 参数说明。 */
     description?: string;
     /** 是否必填。 */
@@ -50,31 +54,42 @@ export interface ModuleActionResponse {
     /** 响应示例。 */
     example?: unknown;
 }
-/** 模块动作渲染目标类型；保留给 CLI 等上层应用使用。 */
-export type ModuleActionResultRenderType = 'markdown' | 'json' | 'raw';
-/** 模块动作自定义渲染函数类型；SDK 本身不直接渲染终端输出。 */
-export type ModuleActionResultRender = (result: unknown, type: ModuleActionResultRenderType, action: ModuleAction) => string;
-/** 从原始响应中提取分页字段时使用的字段映射。 */
+/** 从原始响应中提取分页字段时使用的字段映射，值为原始响应中的字段路径（支持 `a.b` 嵌套）。 */
 export interface ModuleActionPagerGetterMap {
-    /** 当前页码字段名。 */
+    /** 当前页码字段路径。 */
     pageID: string;
-    /** 每页记录数字段名。 */
+    /** 每页记录数字段路径。 */
     recPerPage: string;
-    /** 总记录数字段名。 */
+    /** 总记录数字段路径。 */
     recTotal: string;
 }
+/**
+ * 从原始响应中重映射业务数据字段的映射表。
+ * 键为输出字段名，值为原始响应中的字段路径（支持 `a.b` 嵌套）。
+ */
+export type ModuleActionResultFieldMap = Readonly<Record<string, string>>;
+/**
+ * 从原始响应中提取数据时使用的函数形态。
+ * @param data 原始响应对象。
+ * @param params 触发本次请求的原始调用参数。
+ */
+export type ModuleActionGetterFn<T> = (data: unknown, params: Record<string, unknown>) => T;
 /** 禅道模块中的单个 API 动作定义。 */
 export interface ModuleAction {
     /** 动作名称，例如 `list`、`get`、`close`。 */
     name: ModuleActionName;
-    /** 动作类型，决定高阶 request 的路径/参数解析策略。 */
+    /** 动作类型，决定高阶 request 的路径/参数解析策略，并在 `method`、`resultType` 省略时作为推导依据。 */
     type: ModuleActionType;
     /** 面向用户展示的动作名称。 */
     display?: string;
     /** 动作说明。 */
     description?: string;
-    /** HTTP 方法。 */
-    method: ModuleActionMethod;
+    /**
+     * HTTP 方法；省略时按 {@link type} 自动推导：
+     * `list`/`get` → `GET`、`create`/`action` → `POST`、`update` → `PUT`、`delete` → `DELETE`。
+     * 当 `type` 无法推导出方法时抛出 `E_INDETERMINATE_ACTION_METHOD`。
+     */
+    method?: ModuleActionMethod;
     /** API 路径模板，可包含 `{productID}` 等路径参数。 */
     path: string;
     /** 路径参数定义；字符串为说明，对象可携带默认值和可选项。 */
@@ -83,14 +98,22 @@ export interface ModuleAction {
     params?: readonly ModuleActionParam[];
     /** 请求体定义。 */
     requestBody?: ModuleActionRequestBody;
-    /** 结果形态。 */
-    resultType: ModuleActionResultType;
-    /** 从原始响应中提取分页信息的位置或函数。 */
-    pagerGetter?: string | ModuleActionPagerGetterMap | ((data: unknown, params: Record<string, unknown>) => ListPagerInfo);
-    /** 从原始响应中提取业务数据的位置或函数。 */
-    resultGetter?: string | Record<string, string> | ((data: unknown, params: Record<string, unknown>) => unknown);
-    /** 供上层应用使用的渲染配置。 */
-    render?: string | ModuleActionResultRender | Record<ModuleActionResultRenderType, ModuleActionResultRender>;
+    /**
+     * 结果形态；省略时按 {@link type} 自动推导：
+     * `list` → `list`、`get`/`create`/`update` → `object`、`delete`/`action` → `text`。
+     * 当 `type` 无法推导出结果形态时抛出 `E_INDETERMINATE_ACTION_RESULT_TYPE`。
+     */
+    resultType?: ModuleActionResultType;
+    /**
+     * 从原始响应中提取分页信息的位置或函数：
+     * 字符串为字段路径（支持 `a.b` 嵌套）、对象为字段映射、函数则接收原始响应与调用参数。
+     */
+    pagerGetter?: string | ModuleActionPagerGetterMap | ModuleActionGetterFn<ListPagerInfo>;
+    /**
+     * 从原始响应中提取业务数据的位置或函数：
+     * 字符串为字段路径（支持 `a.b` 嵌套）、对象为字段映射、函数则接收原始响应与调用参数。
+     */
+    resultGetter?: string | ModuleActionResultFieldMap | ModuleActionGetterFn<unknown>;
 }
 /** 内置模块名称，同时允许用户扩展自定义模块名。 */
 export type ModuleName = 'user' | 'program' | 'product' | 'project' | 'execution' | 'productplan' | 'story' | 'epic' | 'requirement' | 'bug' | 'testcase' | 'task' | 'feedback' | 'ticket' | 'system' | 'build' | 'testtask' | 'release' | 'file' | (string & {});
@@ -106,7 +129,7 @@ export interface ModuleDefinition {
     actions: readonly ModuleAction[];
 }
 /** 将模块动作和参数解析后的可执行请求描述。 */
-export interface ResolvedModuleCommand {
+export interface ModuleActionRequest {
     /** 模块名称。 */
     module: string;
     /** 匹配到的动作定义。 */

package/dist/types/options.d.ts

@@ -16,6 +16,12 @@ export interface GlobalOptions {
     persistProfiles?: boolean;
     /** 当禅道服务端返回 `{ status: "fail" }` 时是否抛出 `E_API_FAILED`，默认 false。 */
     throwOnFail?: boolean;
+    /**
+     * 是否在执行 `update` 操作时自动填充未传入的字段，默认 false。
+     *
+     * 优先级低于单次请求选项；语义见 {@link RequestOptions.autoFill}。
+     */
+    autoFill?: boolean;
 }
 /** 高阶 `request("moduleName")` / `request("moduleName/methodName")` / `request("moduleName/<objectID>")` 的单次调用选项。 */
 export interface RequestOptions extends ProcessListOptions {
@@ -32,4 +38,16 @@ export interface RequestOptions extends ProcessListOptions {
      * 不传时回落到全局 `throwOnFail`，默认 false（保留原始失败响应）。
      */
     throwOnFail?: boolean;
+    /**
+     * 是否在执行 `update` 操作时自动填充未传入的字段。
+     *
+     * 设为 `true` 后，会先 GET 当前对象，把用户未显式传入（含 `params.data`）且
+     * 动作 body schema 中声明的字段用现值补齐，再发起 PUT，避免禅道用空值覆盖未提交字段。
+     * 因此只需传想修改的字段即可。仅对 `type: 'update'` 且模块存在 `type: 'get'` 动作时生效。
+     *
+     * 不传时回落到全局 `autoFill`，默认 false。
+     */
+    autoFill?: boolean;
+    /** 是否返回原始响应体，默认 false。 */
+    raw?: boolean;
 }

package/dist/utils/index.d.ts

@@ -1,4 +1,4 @@
-export { isRecord, getNestedValue } from './object.js';
+export { isRecord, isBlank, getNestedValue } from './object.js';
 export { asArray } from './array.js';
 export { normalizeSiteUrl } from './url.js';
 export { pickFields, pickFieldsSingle, filterData, searchData, sortData, processData, } from './data.js';

package/dist/utils/index.js

@@ -1,4 +1,4 @@
-export { isRecord, getNestedValue } from './object.js';
+export { isRecord, isBlank, getNestedValue } from './object.js';
 export { asArray } from './array.js';
 export { normalizeSiteUrl } from './url.js';
 export { pickFields, pickFieldsSingle, filterData, searchData, sortData, processData, } from './data.js';

package/dist/utils/object.d.ts

@@ -1,3 +1,5 @@
 /** 判断值是否为普通对象（非数组、非 null）。 */
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** 判断值是否为“空”（undefined、null 或空字符串）。 */
+export declare function isBlank(value: unknown): boolean;
 export declare function getNestedValue(obj: unknown, path: string): unknown;

package/dist/utils/object.js

@@ -2,6 +2,10 @@
 export function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
+/** 判断值是否为“空”（undefined、null 或空字符串）。 */
+export function isBlank(value) {
+    return value === undefined || value === null || value === '';
+}
 export function getNestedValue(obj, path) {
     const keys = path.split('.');
     let current = obj;

package/dist/version.js

@@ -1,5 +1,5 @@
-const fallbackBuild = "2026-06-29T10:27:50.494Z";
-const fallbackVersion = "0.3.2";
+const fallbackBuild = "2026-07-21T02:40:34.356Z";
+const fallbackVersion = "0.4.0";
 /**
  * 构建标识，由构建脚本通过 `__ZENTAO_API_BUILD__` 注入。
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zentao-api",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "type": "module",
   "description": "Browser and Node.js SDK for ZenTao API",
   "license": "MIT",