@aithe/aithe-ui 26.2.3 → 26.3.2

package/dist/core/autoform/condition.js

@@ -0,0 +1,170 @@
+/**
+ * @file Form condition expression parser and evaluator / 表单条件表达式解析与求值
+ * @description Parses condition expressions like "field === 'value' || field2 > 10"
+ * into an AST and evaluates them against a values map.
+ * 将条件表达式（如 "field === 'value' || field2 > 10"）解析为 AST 并基于值映射求值。
+ */
+import { safeStringify } from '../../utils/utils';
+const TRUTHY_STRINGS = new Set(['true', '1', 'yes', 'on']);
+const FALSY_STRINGS = new Set(['false', '0', 'no', 'off', '', 'null', 'undefined']);
+/**
+ * Form condition expression parser and evaluator.
+ * 表单条件表达式解析与求值器。
+ * @description Parses condition expressions like "field === 'value' || field2 > 10"
+ * into an AST and evaluates them against a values map.
+ * Supports comparison operators (===, !==, >, >=, <, <=), logical AND (&&) and OR (||),
+ * nested parentheses, and automatic type coercion for comparison.
+ * 将条件表达式（如 "field === 'value' || field2 > 10"）解析为 AST 并基于值映射求值。
+ * 支持比较运算符、逻辑与/或、嵌套括号及自动类型转换。
+ */
+export class FormCondition {
+    /**
+     * Evaluate a condition expression against form values.
+     * 对条件表达式进行求值。
+     * @param condition - 条件表达式字符串 / Condition expression string
+     * @param values - 当前表单字段值映射 / Current form field values map
+     * @returns 求值结果，条件为空时返回 true / Evaluation result, returns true if condition is empty
+     */
+    static evaluate(condition, values) {
+        const node = FormCondition.parse(condition);
+        if (!node)
+            return true;
+        return FormCondition.evaluateNode(node, values);
+    }
+    /**
+     * Parse a condition expression string into an AST.
+     * 将条件表达式字符串解析为 AST。
+     * @param expr - 表达式字符串 / Expression string
+     * @returns AST 根节点，空字符串返回 null / Root AST node, or null for empty string
+     */
+    static parse(expr) {
+        const trimmed = expr.trim();
+        if (!trimmed)
+            return null;
+        const orParts = FormCondition.splitLogical(trimmed, '||');
+        if (orParts.length > 1) {
+            const children = orParts
+                .map((p) => FormCondition.parse(p))
+                .filter((n) => n !== null);
+            return children.length > 0 ? { kind: 'or', children } : null;
+        }
+        const andParts = FormCondition.splitLogical(trimmed, '&&');
+        if (andParts.length > 1) {
+            const children = andParts
+                .map((p) => FormCondition.parse(p))
+                .filter((n) => n !== null);
+            return children.length > 0 ? { kind: 'and', children } : null;
+        }
+        return FormCondition.parseSingleComparison(trimmed);
+    }
+    static evaluateNode(node, values) {
+        if (node.kind === 'comparison') {
+            const fieldValue = values[node.field] ?? '';
+            return FormCondition.compareValues(fieldValue, node.operator, node.value);
+        }
+        if (node.kind === 'and') {
+            return node.children.every((child) => FormCondition.evaluateNode(child, values));
+        }
+        if (node.kind === 'or') {
+            return node.children.some((child) => FormCondition.evaluateNode(child, values));
+        }
+        return false;
+    }
+    static toComparable(val) {
+        if (val === null || val === undefined)
+            return '';
+        if (typeof val === 'boolean')
+            return val;
+        if (typeof val === 'number')
+            return val;
+        const str = safeStringify(val);
+        if (TRUTHY_STRINGS.has(str))
+            return true;
+        if (FALSY_STRINGS.has(str))
+            return false;
+        const num = Number(str);
+        if (str !== '' && !Number.isNaN(num))
+            return num;
+        return str;
+    }
+    static compareValues(left, operator, right) {
+        const lv = FormCondition.toComparable(left);
+        const rv = FormCondition.toComparable(right);
+        switch (operator) {
+            case '===':
+                return lv === rv;
+            case '!==':
+                return lv !== rv;
+            case '>':
+                return typeof lv === 'number' && typeof rv === 'number' && lv > rv;
+            case '>=':
+                return typeof lv === 'number' && typeof rv === 'number' && lv >= rv;
+            case '<':
+                return typeof lv === 'number' && typeof rv === 'number' && lv < rv;
+            case '<=':
+                return typeof lv === 'number' && typeof rv === 'number' && lv <= rv;
+            default:
+                return false;
+        }
+    }
+    static parseLiteral(raw) {
+        const trimmed = raw.trim();
+        if (trimmed === 'true')
+            return true;
+        if (trimmed === 'false')
+            return false;
+        if (trimmed === 'null')
+            return null;
+        if (trimmed === 'undefined')
+            return undefined;
+        if (/^-?\d+(\.\d+)?$/.test(trimmed))
+            return Number(trimmed);
+        if ((trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+            (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
+            return trimmed.slice(1, -1);
+        }
+        return trimmed;
+    }
+    static parseSingleComparison(expr) {
+        const re = /^\s*([a-zA-Z_]\w*)\s*(===|!==|>=|<=|>|<)\s*(.+?)\s*$/;
+        const match = re.exec(expr);
+        if (!match?.[1] || !match?.[2] || match[3] === undefined)
+            return null;
+        return {
+            kind: 'comparison',
+            field: match[1],
+            operator: match[2],
+            value: FormCondition.parseLiteral(match[3]),
+        };
+    }
+    static splitLogical(expr, op) {
+        const parts = [];
+        let depth = 0;
+        let current = '';
+        let i = 0;
+        while (i < expr.length) {
+            if (expr[i] === '(') {
+                depth++;
+                current += expr[i];
+                i++;
+            }
+            else if (expr[i] === ')') {
+                depth--;
+                current += expr[i];
+                i++;
+            }
+            else if (depth === 0 && expr.slice(i, i + op.length) === op) {
+                parts.push(current);
+                current = '';
+                i += op.length;
+            }
+            else {
+                current += expr[i];
+                i++;
+            }
+        }
+        if (current.trim())
+            parts.push(current);
+        return parts;
+    }
+}

package/dist/core/autoform/index.d.ts

@@ -8,4 +8,6 @@ export { FormRuleEngine, FormRegistry } from './autoform';
 export type { FormDependencyState, FormControlRenderer, FormControlContext, FormControlDefinition, } from './autoform';
 export { FormCondition } from './condition';
 export type { FormRule, FormRuleType, FormFieldConfig, FormItemOption } from './types';
+export { ViewRegistry } from './autoview';
+export type { ViewFieldConfig, ViewRenderContext, ViewRenderer, ViewControlDefinition, } from './autoview';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/autoform/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/autoform/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1D,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/autoform/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1D,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEvF,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,GACtB,MAAM,YAAY,CAAC"}

package/dist/core/autoform/index.js

@@ -0,0 +1,9 @@
+/**
+ * @file Form module entry — unified exports / 表单模块入口 — 统一导出
+ * @description Re-exports all public APIs from the form module:
+ * FormRuleEngine, FormRegistry, FormCondition, and all related types.
+ * 重新导出表单模块的所有公开 API：规则引擎、控件注册表、条件解析器及相关类型。
+ */
+export { FormRuleEngine, FormRegistry } from './autoform';
+export { FormCondition } from './condition';
+export { ViewRegistry } from './autoview';

package/dist/core/autoform/types.js

@@ -0,0 +1,7 @@
+/**
+ * @file Form module shared types / 表单模块共享类型定义
+ * @description Core type definitions for the form dependency rule engine, migrated from components/form
+ * to eliminate circular dependency between core and components.
+ * 表单依赖联动规则引擎核心类型定义，从 components/form 迁移至此，消除 core 与 components 之间的循环依赖。
+ */
+export {};

package/dist/core/datahub/__tests__/force-options.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file DataHubCore forceDedup / forceCache 选项测试
+ * @description 验证当 URL 不以 query/list/get 结尾时，
+ *              forceDedup 和 forceCache 选项能强制启用去重和缓存，
+ *              且不会被幂等守卫拦截。
+ */
+export {};
+//# sourceMappingURL=force-options.test.d.ts.map

package/dist/core/datahub/__tests__/force-options.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"force-options.test.d.ts","sourceRoot":"","sources":["../../../../src/core/datahub/__tests__/force-options.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/core/datahub/__tests__/force-options.test.js

@@ -0,0 +1,161 @@
+/**
+ * @file DataHubCore forceDedup / forceCache 选项测试
+ * @description 验证当 URL 不以 query/list/get 结尾时，
+ *              forceDedup 和 forceCache 选项能强制启用去重和缓存，
+ *              且不会被幂等守卫拦截。
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DataHubCore } from '../../datahub/core/datahub-core';
+/** 构造一个可控的假适配器 / Build a controllable fake adapter */
+function createFakeAdapter() {
+    const adapter = {
+        name: 'fake',
+        callCount: 0,
+        reset() {
+            this.callCount = 0;
+        },
+        async request(req) {
+            this.callCount++;
+            return { ok: true, status: 200, data: { url: req.url, n: this.callCount } };
+        },
+    };
+    return adapter;
+}
+/** 构造一个使用 raw APIStyle 的 DataHubCore（不做业务协议解析）/ Build a DataHubCore with raw APIStyle */
+function createCore(adapter) {
+    const core = new DataHubCore({ defaultCacheTTL: 1000, defaultAdapter: adapter.name });
+    core.registerAdapter(adapter);
+    core.setAPIStyle('raw');
+    return core;
+}
+beforeEach(() => {
+    // 每个用例前清空全局缓存和去重记录，避免用例间相互干扰
+    // Clear global cache and dedup records before each case to avoid cross-test interference
+});
+describe('DataHubCore - forceDedup', () => {
+    it('非 query URL 默认走幂等守卫，并发第二个请求被拒绝', async () => {
+        const fake = createFakeAdapter();
+        const core = createCore(fake);
+        // /system/roles/viewer 结尾不是 query/list/get，默认判为 submit
+        const p1 = core.request('/system/roles/viewer', undefined, { method: 'GET' });
+        const p2 = core.request('/system/roles/viewer', undefined, { method: 'GET' });
+        // p2 应被幂等守卫拒绝
+        await expect(p2).rejects.toThrow(/duplicate submit/);
+        await p1;
+        expect(fake.callCount).toBe(1);
+    });
+    it('forceDedup: true 时，非 query URL 并发请求被去重，只发一次', async () => {
+        const fake = createFakeAdapter();
+        const core = createCore(fake);
+        core.clearDedup();
+        core.clearIdempotent();
+        const p1 = core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceDedup: true,
+        });
+        const p2 = core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceDedup: true,
+        });
+        const [r1, r2] = await Promise.all([p1, p2]);
+        // 两个调用共享同一结果，只发一次实际请求
+        expect(fake.callCount).toBe(1);
+        expect(r1).toEqual(r2);
+    });
+    it('forceDedup 不影响不同 URL 的请求', async () => {
+        const fake = createFakeAdapter();
+        const core = createCore(fake);
+        core.clearDedup();
+        core.clearIdempotent();
+        await Promise.all([
+            core.request('/system/roles/a', undefined, { method: 'GET', forceDedup: true }),
+            core.request('/system/roles/b', undefined, { method: 'GET', forceDedup: true }),
+        ]);
+        expect(fake.callCount).toBe(2);
+    });
+});
+describe('DataHubCore - forceCache', () => {
+    it('非 query URL 默认不缓存，两次请求发两次', async () => {
+        const fake = createFakeAdapter();
+        const core = createCore(fake);
+        core.clearCache();
+        core.clearIdempotent();
+        await core.request('/system/roles/viewer', undefined, { method: 'GET', skipIdempotent: true });
+        await core.request('/system/roles/viewer', undefined, { method: 'GET', skipIdempotent: true });
+        expect(fake.callCount).toBe(2);
+    });
+    it('forceCache: true 时，非 query URL 第二次请求命中缓存', async () => {
+        const fake = createFakeAdapter();
+        const core = createCore(fake);
+        core.clearCache();
+        core.clearIdempotent();
+        const r1 = await core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceCache: true,
+            skipIdempotent: true,
+        });
+        const r2 = await core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceCache: true,
+            skipIdempotent: true,
+        });
+        // 第二次命中缓存，只发一次实际请求
+        expect(fake.callCount).toBe(1);
+        expect(r1).toEqual(r2);
+    });
+    it('forceCache 配合 skipCache 时不命中缓存', async () => {
+        const fake = createFakeAdapter();
+        const core = createCore(fake);
+        core.clearCache();
+        core.clearIdempotent();
+        await core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceCache: true,
+            skipIdempotent: true,
+        });
+        await core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceCache: true,
+            skipCache: true,
+            skipIdempotent: true,
+        });
+        expect(fake.callCount).toBe(2);
+    });
+});
+describe('DataHubCore - forceDedup + forceCache 跳过幂等守卫', () => {
+    it('forceDedup 为 true 时，即使 URL 被判为 submit 也不会触发幂等守卫', async () => {
+        const fake = createFakeAdapter();
+        const core = createCore(fake);
+        core.clearDedup();
+        core.clearIdempotent();
+        // 串行两次请求（不并发），验证幂等守卫不会拦截第二次
+        await core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceDedup: true,
+        });
+        // 第二次请求不应被幂等守卫拒绝（dedup 记录已清理，会重新发请求）
+        const r2 = await core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceDedup: true,
+        });
+        expect(r2.ok).toBe(true);
+        expect(fake.callCount).toBe(2);
+    });
+    it('forceCache 为 true 时，即使 URL 被判为 submit 也不会触发幂等守卫', async () => {
+        const fake = createFakeAdapter();
+        const core = createCore(fake);
+        core.clearCache();
+        core.clearIdempotent();
+        await core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceCache: true,
+        });
+        // 第二次命中缓存，且不被幂等守卫拦截
+        const r2 = await core.request('/system/roles/viewer', undefined, {
+            method: 'GET',
+            forceCache: true,
+        });
+        expect(r2.ok).toBe(true);
+        expect(fake.callCount).toBe(1);
+    });
+});

package/dist/core/datahub/config/strategy.d.ts

@@ -10,7 +10,7 @@
  *              - Query strategy: cacheable, dedupable, retryable
  *              - Submit strategy: idempotent guard, no cache, no retry
  */
-import type { DataHubStrategyConfig } from '../types';
+import type { DataHubStrategyConfig } from '../../datahub/types';
 /**
  * 根据 URL 解析请求策略 / Resolve request strategy based on URL
  * @param url - 请求地址 / Request URL

package/dist/core/datahub/config/strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../../src/core/datahub/config/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAuB,MAAM,UAAU,CAAC;AA0B3E;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAIlE"}
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../../src/core/datahub/config/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAuB,MAAM,qBAAqB,CAAC;AA0BtF;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAIlE"}

package/dist/core/datahub/config/strategy.js

@@ -0,0 +1,50 @@
+/**
+ * @file 策略配置 / Strategy Configuration
+ * @description 根据 URL 自动识别请求策略（查询 or 提交），
+ *              并返回对应的策略配置。策略决定了请求经过哪些中间件处理：
+ *              - 查询策略（query）：可缓存、可去重、可重试
+ *              - 提交策略（submit）：幂等防护、不缓存、不重试
+ *              Automatically identifies the request strategy (query or submit) based on the URL,
+ *              and returns the corresponding strategy config. Strategy determines which middleware
+ *              the request passes through:
+ *              - Query strategy: cacheable, dedupable, retryable
+ *              - Submit strategy: idempotent guard, no cache, no retry
+ */
+import { isQueryAction } from '../../datahub/utils/is-query';
+/**
+ * 策略映射表 / Strategy mapping table
+ * @description 定义两种策略的完整行为配置 / Defines the complete behavior config for both strategies
+ */
+const STRATEGY_MAP = {
+    /** 查询策略：结果可缓存，并发请求可去重，失败可重试 / Query strategy: cacheable results, dedupable concurrent requests, retryable on failure */
+    query: {
+        type: 'query',
+        cacheable: true,
+        dedupable: true,
+        idempotent: false,
+        retryable: true,
+    },
+    /** 提交策略：不缓存，不去重，需幂等防护，失败不重试 / Submit strategy: no cache, no dedup, idempotent guard required, no retry on failure */
+    submit: {
+        type: 'submit',
+        cacheable: false,
+        dedupable: false,
+        idempotent: true,
+        retryable: false,
+    },
+};
+/**
+ * 根据 URL 解析请求策略 / Resolve request strategy based on URL
+ * @param url - 请求地址 / Request URL
+ * @returns 策略配置（返回副本，避免外部修改影响全局配置）/ Strategy config (returns a copy to prevent external mutation)
+ *
+ * @example
+ * resolveStrategy('/order/query')   // { type: 'query', cacheable: true, ... }
+ * resolveStrategy('/order/submit')  // { type: 'submit', idempotent: true, ... }
+ * resolveStrategy('/order/pay')     // { type: 'submit', idempotent: true, ... }
+ */
+export function resolveStrategy(url) {
+    const type = isQueryAction(url) ? 'query' : 'submit';
+    // 返回副本，防止外部修改影响策略映射表 / Return a copy to prevent external mutation of the strategy map
+    return { ...STRATEGY_MAP[type] };
+}

package/dist/core/datahub/core/adapter/fetch-adapter.d.ts

@@ -16,7 +16,7 @@
  *              4. Support merging external signal with internal timeout signal
  *              5. Propagate traceId via request header
  */
-import type { DataHubAdapter, DataHubAdapterRequest, DataHubAdapterResponse } from '../../types';
+import type { DataHubAdapter, DataHubAdapterRequest, DataHubAdapterResponse } from '../../../datahub/types';
 /**
  * FetchAdapter - 原生 fetch 适配器 / Native fetch adapter
  * @implements {DataHubAdapter}

package/dist/core/datahub/core/adapter/fetch-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/core/datahub/core/adapter/fetch-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAKjG;;;GAGG;AACH,qBAAa,YAAa,YAAW,cAAc;IACjD,wCAAwC;IACxC,SAAgB,IAAI,WAAW;IAE/B;;;;;OAKG;IACU,OAAO,CAAC,CAAC,GAAG,OAAO,EAC9B,GAAG,EAAE,qBAAqB,GACzB,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;IA4DrC;;OAEG;IACI,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAOhC"}
+{"version":3,"file":"fetch-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/core/datahub/core/adapter/fetch-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAKzG;;;GAGG;AACH,qBAAa,YAAa,YAAW,cAAc;IACjD,wCAAwC;IACxC,SAAgB,IAAI,WAAW;IAE/B;;;;;OAKG;IACU,OAAO,CAAC,CAAC,GAAG,OAAO,EAC9B,GAAG,EAAE,qBAAqB,GACzB,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;IA4DrC;;OAEG;IACI,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAOhC"}

package/dist/core/datahub/core/adapter/fetch-adapter.js

@@ -0,0 +1,118 @@
+/**
+ * @file FetchAdapter - 浏览器原生 fetch 适配器 / Browser Native Fetch Adapter
+ * @description 基于 window.fetch 实现的零依赖 HTTP 适配器。
+ *              职责：
+ *              1. 将 DataHubAdapterRequest 转换为 fetch 调用
+ *              2. 解析 JSON 响应为原始数据，不假设任何业务协议结构
+ *              3. 支持超时自动中断（AbortController）
+ *              4. 支持外部 signal 与内部超时 signal 合并
+ *              5. traceId 通过请求头透传
+ *
+ *              Zero-dependency HTTP adapter based on window.fetch.
+ *              Responsibilities:
+ *              1. Convert DataHubAdapterRequest to fetch calls
+ *              2. Parse JSON responses as raw data, assuming no business protocol structure
+ *              3. Support timeout-based auto-abort (AbortController)
+ *              4. Support merging external signal with internal timeout signal
+ *              5. Propagate traceId via request header
+ */
+/** 按 URL 存储的 AbortController 映射，用于主动取消请求 / AbortController map keyed by URL for active request cancellation */
+const abortControllers = new Map();
+/**
+ * FetchAdapter - 原生 fetch 适配器 / Native fetch adapter
+ * @implements {DataHubAdapter}
+ */
+export class FetchAdapter {
+    constructor() {
+        /** 适配器名称标识 / Adapter name identifier */
+        this.name = 'fetch';
+    }
+    /**
+     * 执行 HTTP 请求 / Execute HTTP request
+     * @param req - 适配器请求对象 / Adapter request object
+     * @returns 标准化的适配器响应，data 为原始 JSON 解析结果，不含业务协议假设
+     *          Standardized adapter response, data is raw JSON-parsed result with no business protocol assumptions
+     */
+    async request(req) {
+        const { url, data, options } = req;
+        const method = options.method ?? 'POST';
+        const timeout = options.timeout ?? 30000;
+        const controller = new AbortController();
+        abortControllers.set(url, controller);
+        const signal = options.signal
+            ? composeSignals(options.signal, controller.signal)
+            : controller.signal;
+        const init = {
+            method,
+            signal,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        };
+        if (method !== 'GET' && data !== undefined) {
+            init.body = JSON.stringify(data);
+        }
+        if (method === 'GET' && data !== undefined) {
+            console.warn(`[DataHub] GET request with body is unusual: ${url}`);
+        }
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(url, init);
+            const resHeaders = {};
+            for (const [k, v] of response.headers) {
+                resHeaders[k] = v;
+            }
+            // 只解析 JSON，不做任何业务语义判断
+            // Only parse JSON, no business semantics
+            let json;
+            try {
+                json = (await response.json());
+            }
+            catch {
+                json = undefined;
+            }
+            return {
+                ok: response.ok,
+                status: response.status,
+                data: json,
+                headers: resHeaders,
+            };
+        }
+        finally {
+            clearTimeout(timer);
+            abortControllers.delete(url);
+        }
+    }
+    /**
+     * 主动取消指定 URL 的请求 / Actively abort the request for the specified URL
+     */
+    abort(url) {
+        const controller = abortControllers.get(url);
+        if (controller) {
+            controller.abort();
+            abortControllers.delete(url);
+        }
+    }
+}
+/**
+ * 合并两个 AbortSignal / Compose two AbortSignals
+ */
+function composeSignals(external, internal) {
+    const controller = new AbortController();
+    const cleanup = () => {
+        external.removeEventListener('abort', onAbort);
+        internal.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => {
+        cleanup();
+        controller.abort();
+    };
+    external.addEventListener('abort', onAbort, { once: true });
+    internal.addEventListener('abort', onAbort, { once: true });
+    if (external.aborted || internal.aborted) {
+        cleanup();
+        controller.abort();
+    }
+    return controller.signal;
+}

package/dist/core/datahub/core/adapter/index.js

@@ -0,0 +1,7 @@
+/**
+ * @file 适配器导出 / Adapter Exports
+ * @description 统一导出内置适配器，方便外部按需引入或扩展。
+ *              Unified export of built-in adapters for on-demand import or extension.
+ */
+export { FetchAdapter } from './fetch-adapter';
+export { MockAdapter } from './mock-adapter';

package/dist/core/datahub/core/adapter/mock-adapter.d.ts

@@ -12,7 +12,7 @@
  *              2. Support mockDelay to simulate network latency
  *              3. Assume no business protocol structure, return raw mockData directly
  */
-import type { DataHubAdapter, DataHubAdapterRequest, DataHubAdapterResponse } from '../../types';
+import type { DataHubAdapter, DataHubAdapterRequest, DataHubAdapterResponse } from '../../../datahub/types';
 /**
  * MockAdapter - 本地模拟适配器 / Local mock adapter
  * @implements {DataHubAdapter}

package/dist/core/datahub/core/adapter/mock-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/core/datahub/core/adapter/mock-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAEjG;;;GAGG;AACH,qBAAa,WAAY,YAAW,cAAc;IAChD,wCAAwC;IACxC,SAAgB,IAAI,UAAU;IAE9B;;;;;OAKG;IACU,OAAO,CAAC,CAAC,GAAG,OAAO,EAC9B,GAAG,EAAE,qBAAqB,GACzB,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;CAatC"}
+{"version":3,"file":"mock-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/core/datahub/core/adapter/mock-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEzG;;;GAGG;AACH,qBAAa,WAAY,YAAW,cAAc;IAChD,wCAAwC;IACxC,SAAgB,IAAI,UAAU;IAE9B;;;;;OAKG;IACU,OAAO,CAAC,CAAC,GAAG,OAAO,EAC9B,GAAG,EAAE,qBAAqB,GACzB,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;CAyBtC"}

package/dist/core/datahub/core/adapter/mock-adapter.js

@@ -0,0 +1,58 @@
+/**
+ * @file MockAdapter - 本地模拟数据适配器 / Local Mock Data Adapter
+ * @description 用于开发调试阶段模拟后端接口响应，零依赖。
+ *              职责：
+ *              1. 根据配置的 mockData 返回模拟数据
+ *              2. 支持 mockDelay 模拟网络延迟
+ *              3. 不假设任何业务协议结构，直接返回原始 mockData
+ *
+ *              Used during development/debugging to simulate backend API responses, zero dependencies.
+ *              Responsibilities:
+ *              1. Return simulated data based on configured mockData
+ *              2. Support mockDelay to simulate network latency
+ *              3. Assume no business protocol structure, return raw mockData directly
+ */
+/**
+ * MockAdapter - 本地模拟适配器 / Local mock adapter
+ * @implements {DataHubAdapter}
+ */
+export class MockAdapter {
+    constructor() {
+        /** 适配器名称标识 / Adapter name identifier */
+        this.name = 'mock';
+    }
+    /**
+     * 执行模拟请求 / Execute mock request
+     * @param req - 适配器请求对象 / Adapter request object
+     * @returns 模拟的标准化响应，data 为原始 mockData，不含业务协议假设
+     *          Simulated standardized response, data is raw mockData with no business protocol assumptions
+     */
+    async request(req) {
+        const { mockData, mockPath, mockDelay } = req.options;
+        let data;
+        if (mockData !== undefined) {
+            await sleep(mockDelay ?? 300);
+            data = mockData;
+        }
+        else if (mockPath) {
+            const response = await fetch(mockPath);
+            if (!response.ok) {
+                throw new Error(`${response.status} - Fetch mock resource failed: ${mockPath}`);
+            }
+            const text = await response.text();
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                throw new Error(`Mock resource is not valid JSON: ${mockPath}`);
+            }
+        }
+        else {
+            data = {};
+        }
+        return { ok: true, status: 200, data };
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}