Feature/runtime cdn and plugin loader (#240)

* feat(ui): 完善 UI 布局系统和编辑器可视化工具

* refactor: 移除 ModuleRegistry,统一使用 PluginManager 插件系统

* fix: 修复 CodeQL 警告并提升测试覆盖率

* refactor: 分离运行时入口点,解决 runtime bundle 包含 React 的问题

* fix(ci): 添加 editor-core 和 editor-runtime 到 CI 依赖构建步骤

* docs: 完善 ServiceContainer 文档,新增 Symbol.for 模式和 @InjectProperty 说明

* fix(ci): 修复 type-check 失败问题

* fix(ci): 修复类型检查失败问题

* fix(ci): 修复类型检查失败问题

* fix(ci): behavior-tree 构建添加 @tauri-apps 外部依赖

* fix(ci): behavior-tree 添加 @tauri-apps/plugin-fs 类型依赖

* fix(ci): platform-web 添加缺失的 behavior-tree 依赖

* fix(lint): 移除正则表达式中不必要的转义字符
This commit is contained in:
YHH
2025-11-27 20:42:46 +08:00
committed by GitHub
parent 71869b1a58
commit 107439d70c
367 changed files with 10661 additions and 12473 deletions

View File

@@ -1,198 +0,0 @@
import { BehaviorTree } from '../models/BehaviorTree';
import { Node } from '../models/Node';
import { Connection } from '../models/Connection';
import { IValidator, ValidationResult, ValidationError as IValidationError } from '../interfaces/IValidator';
/**
* 行为树验证服务
* 实现所有业务验证规则
*/
export class TreeValidator implements IValidator {
/**
* 验证整个行为树
*/
validateTree(tree: BehaviorTree): ValidationResult {
const errors: IValidationError[] = [];
if (!tree.rootNodeId) {
errors.push({
message: '行为树必须有一个根节点'
});
}
const rootNodes = tree.nodes.filter((n) => n.isRoot());
if (rootNodes.length > 1) {
errors.push({
message: '行为树只能有一个根节点',
nodeId: rootNodes.map((n) => n.id).join(', ')
});
}
tree.nodes.forEach((node) => {
const nodeValidation = this.validateNode(node);
errors.push(...nodeValidation.errors);
});
tree.connections.forEach((connection) => {
const connValidation = this.validateConnection(connection, tree);
errors.push(...connValidation.errors);
});
const cycleValidation = this.validateNoCycles(tree);
errors.push(...cycleValidation.errors);
return {
isValid: errors.length === 0,
errors
};
}
/**
* 验证节点
*/
validateNode(node: Node): ValidationResult {
const errors: IValidationError[] = [];
// 使用模板定义的约束undefined 表示无限制
const maxChildren = (node.template.maxChildren ?? Infinity) as number;
const actualChildren = node.children.length;
if (actualChildren > maxChildren) {
if (node.isRoot()) {
errors.push({
message: '根节点只能连接一个子节点',
nodeId: node.id,
field: 'children'
});
} else if (node.nodeType.isDecorator()) {
errors.push({
message: '装饰节点只能连接一个子节点',
nodeId: node.id,
field: 'children'
});
} else if (node.nodeType.isLeaf()) {
errors.push({
message: '叶子节点不能有子节点',
nodeId: node.id,
field: 'children'
});
} else {
errors.push({
message: `节点子节点数量 (${actualChildren}) 超过最大限制 (${maxChildren})`,
nodeId: node.id,
field: 'children'
});
}
}
return {
isValid: errors.length === 0,
errors
};
}
/**
* 验证连接
*/
validateConnection(connection: Connection, tree: BehaviorTree): ValidationResult {
const errors: IValidationError[] = [];
if (!tree.hasNode(connection.from)) {
errors.push({
message: `源节点不存在: ${connection.from}`,
nodeId: connection.from
});
}
if (!tree.hasNode(connection.to)) {
errors.push({
message: `目标节点不存在: ${connection.to}`,
nodeId: connection.to
});
}
if (connection.from === connection.to) {
errors.push({
message: '节点不能连接到自己',
nodeId: connection.from
});
}
if (tree.hasNode(connection.from) && tree.hasNode(connection.to)) {
const fromNode = tree.getNode(connection.from);
const toNode = tree.getNode(connection.to);
if (connection.isNodeConnection()) {
if (!fromNode.canAddChild()) {
errors.push({
message: `节点 ${connection.from} 无法添加更多子节点`,
nodeId: connection.from
});
}
if (toNode.nodeType.isLeaf() && toNode.hasChildren()) {
errors.push({
message: `叶子节点 ${connection.to} 不能有子节点`,
nodeId: connection.to
});
}
}
}
return {
isValid: errors.length === 0,
errors
};
}
/**
* 验证是否存在循环引用
*/
validateNoCycles(tree: BehaviorTree): ValidationResult {
const errors: IValidationError[] = [];
const visited = new Set<string>();
const recursionStack = new Set<string>();
const dfs = (nodeId: string): boolean => {
if (recursionStack.has(nodeId)) {
errors.push({
message: `检测到循环引用: 节点 ${nodeId}`,
nodeId
});
return true;
}
if (visited.has(nodeId)) {
return false;
}
visited.add(nodeId);
recursionStack.add(nodeId);
const node = tree.getNode(nodeId);
for (const childId of node.children) {
if (dfs(childId)) {
return true;
}
}
recursionStack.delete(nodeId);
return false;
};
if (tree.rootNodeId) {
dfs(tree.rootNodeId);
}
tree.nodes.forEach((node) => {
if (!visited.has(node.id) && !node.isRoot()) {
dfs(node.id);
}
});
return {
isValid: errors.length === 0,
errors
};
}
}

View File

@@ -1 +0,0 @@
export { TreeValidator } from './TreeValidator';