@thornfe/jql2iql 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1526 @@
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { JQLLexer, JQLParser } from "@atlaskit/jql-parser";
+import { TerminalNode } from "antlr4ts/tree/TerminalNode";
+import { RuleNode } from "antlr4ts/tree/RuleNode";
+
+//#region src/constants.ts
+/**
+* JQL 解析树节点类型常量
+*/
+const JQL_CONTEXT = {
+	TERMINAL_CLAUSE: "JqlTerminalClauseContext",
+	NOT_CLAUSE: "JqlNotClauseContext",
+	OR_CLAUSE: "JqlOrClauseContext",
+	AND_CLAUSE: "JqlAndClauseContext",
+	LIST: "JqlListContext",
+	FUNCTION: "JqlFunctionContext",
+	EMPTY: "JqlEmptyContext",
+	VALUE: "JqlValueContext",
+	OPERAND: "JqlOperandContext",
+	QUERY: "JqlQueryContext",
+	WHERE: "JqlWhereContext",
+	ORDER_BY: "JqlOrderByContext",
+	SEARCH_SORT: "JqlSearchSortContext",
+	FUNCTION_NAME: "JqlFunctionNameContext",
+	ARGUMENT_LIST: "JqlArgumentListContext",
+	ARGUMENT: "JqlArgumentContext",
+	EQUALS_CLAUSE: "JqlEqualsClauseContext",
+	COMPARISON_CLAUSE: "JqlComparisonClauseContext",
+	IN_CLAUSE: "JqlInClauseContext",
+	LIKE_CLAUSE: "JqlLikeClauseContext",
+	IS_CLAUSE: "JqlIsClauseContext",
+	STRING: "JqlStringContext",
+	NUMBER: "JqlNumberContext"
+};
+/**
+* 包装节点类型（透明传递给子节点）
+*/
+const WRAPPER_CONTEXTS = [
+	"JqlStringContext",
+	"JqlNumberContext",
+	"JqlNonNumberFieldContext",
+	"JqlListStartContext",
+	"JqlListEndContext",
+	"JqlEqualsOperatorContext",
+	"JqlComparisonOperatorContext",
+	"JqlInOperatorContext",
+	"JqlLikeOperatorContext",
+	"JqlFunctionNameContext",
+	"JqlArgumentContext"
+];
+/**
+* 逻辑操作符常量
+*/
+const LOGICAL_OPERATORS = {
+	AND: "AND",
+	OR: "OR",
+	NOT: "NOT"
+};
+/**
+* IQL 逻辑操作符（小写）
+*/
+const IQL_LOGICAL_OPERATORS = {
+	AND: "and",
+	OR: "or",
+	NOT: "not"
+};
+/**
+* 比较操作符常量
+*/
+const COMPARISON_OPERATORS = {
+	EQUAL: "=",
+	NOT_EQUAL: "!=",
+	GREATER_THAN: ">",
+	GREATER_THAN_OR_EQUAL: ">=",
+	LESS_THAN: "<",
+	LESS_THAN_OR_EQUAL: "<=",
+	LIKE: "~",
+	NOT_LIKE: "!~"
+};
+/**
+* 集合操作符常量
+*/
+const SET_OPERATORS = {
+	IN: "in",
+	NOT_IN: "not in"
+};
+/**
+* 空值操作符常量
+*/
+const NULL_OPERATORS = {
+	IS: "is",
+	IS_NOT: "is not"
+};
+/**
+* 空值关键字
+*/
+const NULL_KEYWORDS = {
+	NULL: "null",
+	NULL_UPPER: "NULL",
+	EMPTY: "EMPTY",
+	EMPTY_LOWER: "empty"
+};
+/**
+* 特殊函数名称
+*/
+const FUNCTION_NAMES = {
+	CURRENT_USER: "currentUser",
+	MEMBERS_OF: "membersOf",
+	CASCADE_OPTION: "cascadeOption"
+};
+/**
+* SQL 子句关键字
+*/
+const SQL_CLAUSES = {
+	ORDER_BY: "order by",
+	ASC: "asc",
+	DESC: "desc"
+};
+/**
+* AST 节点类型
+*/
+const AST_NODE_TYPES = {
+	BINARY_EXPRESSION: "BinaryExpression",
+	LOGICAL_EXPRESSION: "LogicalExpression",
+	JQL_QUERY: "JQLQuery",
+	ORDER_BY_CLAUSE: "OrderByClause",
+	LITERAL: "Literal",
+	FUNCTION: "Function",
+	LIST: "List"
+};
+/**
+* 支持的字段类型列表
+*/
+const SUPPORTED_FIELD_TYPES = {
+	createdBy: "createdBy",
+	updatedBy: "updatedBy",
+	Assignee: "Assignee",
+	Reporter: "Reporter",
+	User: "User",
+	Status: "Status",
+	Version: "Version",
+	CustomVersion: "CustomVersion",
+	Sprint: "Sprint",
+	Priority: "Priority",
+	Workspace: "Workspace",
+	ItemType: "ItemType",
+	Name: "Name",
+	Text: "Text",
+	LongText: "LongText",
+	Key: "Key",
+	Number: "Number",
+	Integer: "Integer",
+	Float: "Float",
+	StoryPoint: "StoryPoint",
+	Date: "Date",
+	createdAt: "createdAt",
+	updatedAt: "updatedAt",
+	UserGroup: "UserGroup",
+	Tree: "Tree",
+	Tag: "Tag",
+	Cascade: "Cascade",
+	Checkbox: "Checkbox",
+	Dropdown: "Dropdown",
+	Radio: "Radio"
+};
+
+//#endregion
+//#region src/jql-to-ast/parser-utils.ts
+const OPERATOR_SET = new Set([
+	COMPARISON_OPERATORS.EQUAL,
+	COMPARISON_OPERATORS.NOT_EQUAL,
+	COMPARISON_OPERATORS.GREATER_THAN,
+	COMPARISON_OPERATORS.LESS_THAN,
+	COMPARISON_OPERATORS.GREATER_THAN_OR_EQUAL,
+	COMPARISON_OPERATORS.LESS_THAN_OR_EQUAL,
+	COMPARISON_OPERATORS.LIKE,
+	COMPARISON_OPERATORS.NOT_LIKE,
+	SET_OPERATORS.IN,
+	SET_OPERATORS.NOT_IN
+]);
+new Set([
+	LOGICAL_OPERATORS.AND.toLowerCase(),
+	LOGICAL_OPERATORS.OR.toLowerCase(),
+	LOGICAL_OPERATORS.NOT.toLowerCase()
+]);
+const CLAUSE_OPERATORS = {
+	[JQL_CONTEXT.EQUALS_CLAUSE]: [COMPARISON_OPERATORS.EQUAL, COMPARISON_OPERATORS.NOT_EQUAL],
+	[JQL_CONTEXT.COMPARISON_CLAUSE]: [
+		COMPARISON_OPERATORS.GREATER_THAN,
+		COMPARISON_OPERATORS.LESS_THAN,
+		COMPARISON_OPERATORS.GREATER_THAN_OR_EQUAL,
+		COMPARISON_OPERATORS.LESS_THAN_OR_EQUAL
+	],
+	[JQL_CONTEXT.IN_CLAUSE]: [SET_OPERATORS.IN, SET_OPERATORS.NOT_IN],
+	[JQL_CONTEXT.LIKE_CLAUSE]: [COMPARISON_OPERATORS.LIKE, COMPARISON_OPERATORS.NOT_LIKE],
+	[JQL_CONTEXT.IS_CLAUSE]: [NULL_OPERATORS.IS, NULL_OPERATORS.IS_NOT]
+};
+/**
+* 遍历 JQL 解析树
+* @param tree 解析树根节点
+* @param callback 遍历回调函数，返回 false 可以跳过子节点
+* @param depth 当前深度（内部使用）
+* @param parent 父节点（内部使用）
+*/
+function traverseJQLTree(tree, callback, depth = 0, parent) {
+	if (callback(tree, depth, parent) === false) return;
+	const childCount = tree.childCount;
+	for (let i = 0; i < childCount; i++) traverseJQLTree(tree.getChild(i), callback, depth + 1, tree);
+}
+/**
+* 获取节点信息
+*/
+function getNodeInfo(node) {
+	if (node instanceof TerminalNode) {
+		var _node$symbol$type;
+		return {
+			type: "terminal",
+			text: node.text,
+			tokenType: (_node$symbol$type = node.symbol.type) === null || _node$symbol$type === void 0 ? void 0 : _node$symbol$type.toString()
+		};
+	} else if (node instanceof RuleNode) return {
+		type: "rule",
+		text: node.text,
+		ruleName: node.constructor.name
+	};
+	return {
+		type: "rule",
+		text: node.text
+	};
+}
+/**
+* 获取所有子节点
+*/
+function getChildren(node) {
+	const children = [];
+	for (let i = 0; i < node.childCount; i++) children.push(node.getChild(i));
+	return children;
+}
+/**
+* 提取字段名或简单值
+*/
+function extractFieldValue(node) {
+	if (!node) return null;
+	if (node instanceof TerminalNode) return node.text;
+	if (node instanceof RuleNode) {
+		const ruleName = node.constructor.name;
+		if (ruleName === JQL_CONTEXT.STRING || ruleName === JQL_CONTEXT.NUMBER) return node.text;
+	}
+	for (let i = 0; i < node.childCount; i++) {
+		const value = extractFieldValue(node.getChild(i));
+		if (value) return value;
+	}
+	return null;
+}
+/**
+* 提取操作符
+*/
+function extractOperator(node) {
+	var _constructor;
+	if (!node) return null;
+	if (node instanceof TerminalNode) {
+		const text = node.text;
+		const lowerText = text.toLowerCase();
+		return OPERATOR_SET.has(text) || OPERATOR_SET.has(lowerText) ? text : null;
+	}
+	const operators = CLAUSE_OPERATORS[((_constructor = node.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) || ""];
+	if (operators) return extractOperatorFromClause(node, operators);
+	for (let i = 0; i < node.childCount; i++) {
+		const result = extractOperator(node.getChild(i));
+		if (result) return result;
+	}
+	return null;
+}
+/**
+* 从特定类型的子句中提取操作符
+*/
+function extractOperatorFromClause(node, possibleOperators) {
+	let multiWordOps = null;
+	const singleWordOps = /* @__PURE__ */ new Set();
+	for (const op of possibleOperators) if (op.includes(" ")) {
+		if (!multiWordOps) multiWordOps = [];
+		multiWordOps.push(op);
+	} else singleWordOps.add(op.toLowerCase());
+	const tokens = [];
+	const collectTokens = (n) => {
+		for (let i = 0; i < n.childCount; i++) {
+			const child = n.getChild(i);
+			if (child instanceof TerminalNode) tokens.push(child.text.toLowerCase());
+			else collectTokens(child);
+		}
+	};
+	if (multiWordOps) {
+		collectTokens(node);
+		if (tokens.length > 1) for (const op of multiWordOps) {
+			const opTokens = op.toLowerCase().split(" ");
+			const opLen = opTokens.length;
+			for (let i = 0; i <= tokens.length - opLen; i++) {
+				let match = true;
+				for (let j = 0; j < opLen; j++) if (tokens[i + j] !== opTokens[j]) {
+					match = false;
+					break;
+				}
+				if (match) return op;
+			}
+		}
+	}
+	for (let i = 0; i < node.childCount; i++) {
+		const child = node.getChild(i);
+		if (child instanceof TerminalNode) {
+			const text = child.text;
+			const lowerText = text.toLowerCase();
+			if (singleWordOps.has(lowerText) || singleWordOps.has(text)) return text;
+		} else {
+			const result = extractOperatorFromClause(child, possibleOperators);
+			if (result) return result;
+		}
+	}
+	return null;
+}
+
+//#endregion
+//#region src/jql-to-ast/ast-builder.ts
+const KEYWORDS = new Set([
+	LOGICAL_OPERATORS.AND,
+	LOGICAL_OPERATORS.OR,
+	LOGICAL_OPERATORS.NOT
+]);
+const OPERATORS = new Set([
+	COMPARISON_OPERATORS.EQUAL,
+	COMPARISON_OPERATORS.NOT_EQUAL,
+	COMPARISON_OPERATORS.GREATER_THAN,
+	COMPARISON_OPERATORS.LESS_THAN,
+	COMPARISON_OPERATORS.GREATER_THAN_OR_EQUAL,
+	COMPARISON_OPERATORS.LESS_THAN_OR_EQUAL,
+	COMPARISON_OPERATORS.LIKE,
+	COMPARISON_OPERATORS.NOT_LIKE
+]);
+const SKIP_TERMINALS = new Set([
+	"(",
+	")",
+	","
+]);
+/**
+* 将 JQL 解析树转换为精简的 AST
+*/
+function buildAST(node) {
+	if (!node) return null;
+	const info = getNodeInfo(node);
+	if (node instanceof TerminalNode) {
+		const text = node.text;
+		if (KEYWORDS.has(text.toUpperCase()) || OPERATORS.has(text)) return null;
+		return {
+			type: "Literal",
+			value: text
+		};
+	}
+	const ruleName = info.ruleName || "";
+	if (ruleName === JQL_CONTEXT.TERMINAL_CLAUSE) return buildTerminalClauseAST(node);
+	if (ruleName === JQL_CONTEXT.NOT_CLAUSE) return buildNotClauseAST(node);
+	if (ruleName === JQL_CONTEXT.OR_CLAUSE) return buildOrClauseAST(node);
+	if (ruleName === JQL_CONTEXT.AND_CLAUSE) return buildAndClauseAST(node);
+	if (ruleName === JQL_CONTEXT.LIST) return buildListAST(node);
+	if (ruleName === JQL_CONTEXT.FUNCTION) return buildFunctionAST(node);
+	if (ruleName === JQL_CONTEXT.EMPTY) return {
+		type: "Literal",
+		value: "EMPTY"
+	};
+	if (ruleName === JQL_CONTEXT.VALUE) {
+		const value = extractFieldValue(node);
+		return value ? {
+			type: "Literal",
+			value
+		} : null;
+	}
+	if (ruleName === JQL_CONTEXT.OPERAND) {
+		const children$1 = getChildren(node);
+		for (let i = 0; i < children$1.length; i++) {
+			const result = buildAST(children$1[i]);
+			if (result) return result;
+		}
+		return null;
+	}
+	if (ruleName === JQL_CONTEXT.QUERY) return buildQueryAST(node);
+	if (ruleName === JQL_CONTEXT.WHERE || WRAPPER_CONTEXTS.includes(ruleName)) {
+		const children$1 = getChildren(node);
+		for (let i = 0; i < children$1.length; i++) {
+			const result = buildAST(children$1[i]);
+			if (result) return result;
+		}
+		return null;
+	}
+	const children = getChildren(node);
+	for (let i = 0; i < children.length; i++) {
+		const result = buildAST(children[i]);
+		if (result) return result;
+	}
+	return null;
+}
+/**
+* 构建终端子句 AST (field operator value)
+*/
+function buildTerminalClauseAST(node) {
+	const children = getChildren(node);
+	if (children.length >= 2) {
+		const field = extractFieldValue(children[0]);
+		const operator = extractOperator(children[1]);
+		const value = extractComplexValue(children[1], operator);
+		if (field && operator && value) return {
+			type: "BinaryExpression",
+			operator,
+			left: {
+				type: "Field",
+				value: field
+			},
+			right: value
+		};
+	}
+	return null;
+}
+/**
+* 构建 NOT 子句 AST
+*/
+function buildNotClauseAST(node) {
+	const children = getChildren(node);
+	for (let i = 0; i < children.length; i++) if (children[i] instanceof TerminalNode && children[i].text.toUpperCase() === LOGICAL_OPERATORS.NOT) {
+		const innerExpr = i + 1 < children.length ? buildAST(children[i + 1]) : null;
+		return innerExpr ? {
+			type: "LogicalExpression",
+			operator: LOGICAL_OPERATORS.NOT,
+			left: innerExpr,
+			right: void 0
+		} : null;
+	}
+	for (let i = 0; i < children.length; i++) {
+		const result = buildAST(children[i]);
+		if (result) return result;
+	}
+	return null;
+}
+/**
+* 构建逻辑表达式 AST（OR/AND 通用）
+*/
+function buildLogicalClauseAST(node, operator) {
+	const children = getChildren(node);
+	if (children.length === 1) return buildAST(children[0]);
+	if (children.length < 3) return null;
+	const opIndices = [];
+	for (let i = 0; i < children.length; i++) if (children[i] instanceof TerminalNode && children[i].text.toUpperCase() === operator) opIndices.push(i);
+	if (opIndices.length === 0) return buildAST(children[0]);
+	const lastOpIndex = opIndices[opIndices.length - 1];
+	let result = buildAST(children[lastOpIndex + 1]);
+	for (let i = opIndices.length - 1; i >= 0; i--) {
+		const leftNode = buildAST(children[i === 0 ? 0 : opIndices[i - 1] + 1]);
+		if (leftNode && result) result = {
+			type: "LogicalExpression",
+			operator,
+			left: leftNode,
+			right: result
+		};
+	}
+	return result;
+}
+/**
+* 构建 OR 子句 AST
+*/
+function buildOrClauseAST(node) {
+	return buildLogicalClauseAST(node, LOGICAL_OPERATORS.OR);
+}
+/**
+* 构建 AND 子句 AST
+*/
+function buildAndClauseAST(node) {
+	return buildLogicalClauseAST(node, LOGICAL_OPERATORS.AND);
+}
+/**
+* 构建列表 AST
+*/
+function buildListAST(node) {
+	const children = getChildren(node);
+	const elements = [];
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (child instanceof TerminalNode && SKIP_TERMINALS.has(child.text)) continue;
+		if (getNodeInfo(child).ruleName === JQL_CONTEXT.OPERAND) {
+			const operandValue = buildAST(child);
+			if (operandValue) elements.push(operandValue);
+		}
+	}
+	return {
+		type: "List",
+		elements
+	};
+}
+/**
+* 构建函数 AST
+*/
+function buildFunctionAST(node) {
+	const children = getChildren(node);
+	let functionName = null;
+	const args = [];
+	for (let i = 0; i < children.length; i++) {
+		const info = getNodeInfo(children[i]);
+		if (info.ruleName === JQL_CONTEXT.FUNCTION_NAME) functionName = extractFieldValue(children[i]);
+		else if (info.ruleName === JQL_CONTEXT.ARGUMENT_LIST) {
+			const argChildren = getChildren(children[i]);
+			for (let j = 0; j < argChildren.length; j++) if (getNodeInfo(argChildren[j]).ruleName === JQL_CONTEXT.ARGUMENT) {
+				const argValue = extractFieldValue(argChildren[j]);
+				if (argValue) args.push({
+					type: "Literal",
+					value: argValue
+				});
+			}
+		}
+	}
+	return functionName ? {
+		type: "Function",
+		name: functionName,
+		arguments: args
+	} : null;
+}
+/**
+* 构建查询 AST（包含 WHERE 和 ORDER BY）
+*/
+function buildQueryAST(node) {
+	const children = getChildren(node);
+	let whereClause = null;
+	let orderByClause = null;
+	for (const child of children) {
+		const childInfo = getNodeInfo(child);
+		if (childInfo.ruleName === JQL_CONTEXT.WHERE) whereClause = buildAST(child);
+		else if (childInfo.ruleName === JQL_CONTEXT.ORDER_BY) orderByClause = buildOrderByAST(child);
+	}
+	if (!orderByClause) return whereClause;
+	return {
+		type: "JQLQuery",
+		where: whereClause,
+		orderBy: orderByClause
+	};
+}
+/**
+* 构建 ORDER BY 子句的 AST
+*/
+function buildOrderByAST(node) {
+	if (getNodeInfo(node).ruleName !== JQL_CONTEXT.ORDER_BY) return null;
+	const children = getChildren(node);
+	const fields = [];
+	for (let i = 0; i < children.length; i++) if (getNodeInfo(children[i]).ruleName === JQL_CONTEXT.SEARCH_SORT) {
+		const sortChildren = getChildren(children[i]);
+		let direction = "ASC";
+		let fieldText = "";
+		for (let j = 0; j < sortChildren.length; j++) {
+			const sortChild = sortChildren[j];
+			if (sortChild instanceof TerminalNode) {
+				const text = sortChild.text.toUpperCase();
+				if (text === "ASC" || text === "DESC") {
+					direction = text;
+					break;
+				}
+				fieldText += sortChild.text;
+			} else fieldText += sortChild.text;
+		}
+		const fieldName = fieldText.trim();
+		if (fieldName) fields.push({
+			type: "OrderByField",
+			field: fieldName,
+			direction
+		});
+	}
+	return fields.length > 0 ? {
+		type: "OrderByClause",
+		fields
+	} : null;
+}
+/**
+* 提取复杂值（可能是列表、函数或简单值）
+*/
+function extractComplexValue(node, operator) {
+	if (!node) return null;
+	const priorityContexts = [];
+	if (operator === NULL_OPERATORS.IS || operator === NULL_OPERATORS.IS_NOT) priorityContexts.push(JQL_CONTEXT.EMPTY);
+	else if (operator === SET_OPERATORS.IN || operator === SET_OPERATORS.NOT_IN) priorityContexts.push(JQL_CONTEXT.LIST, JQL_CONTEXT.FUNCTION);
+	else priorityContexts.push(JQL_CONTEXT.FUNCTION, JQL_CONTEXT.VALUE);
+	for (let i = 0; i < node.childCount; i++) {
+		const child = node.getChild(i);
+		const childInfo = getNodeInfo(child);
+		if (priorityContexts.includes(childInfo.ruleName || "")) {
+			const result = buildAST(child);
+			if (result) return result;
+		}
+	}
+	for (let i = 0; i < node.childCount; i++) {
+		const result = extractComplexValue(node.getChild(i), operator);
+		if (result) return result;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/ast-to-iql/field-converters.ts
+/**
+* 规范化字段名，将 cf[xxx] 格式转换为 xxx
+* @param fieldName 原始字段名
+* @returns 规范化后的字段名
+*/
+function normalizeFieldName(fieldName) {
+	const match = fieldName.match(/^cf\[(\d+)\]$/);
+	if (match) return match[1];
+	return fieldName;
+}
+/**
+* 过滤 List 中的函数节点（IQL 不支持的函数）
+* @param elements List 中的元素数组
+* @returns 过滤后的元素数组
+*/
+function filterFunctions(elements) {
+	return elements.filter((el) => el.type !== "Function");
+}
+/**
+* 清理值中的引号包裹
+* @param value 原始值
+* @returns 清理后的值
+*/
+function cleanQuotes(value) {
+	if (value.startsWith("\"") && value.endsWith("\"") && value.length > 1) return value.slice(1, -1);
+	return value;
+}
+/**
+* 通用的字段值转换函数
+* @param value AST 节点
+* @param config 转换配置
+* @returns 转换后的字符串值
+*/
+function convertValue(value, config) {
+	if (value.type === AST_NODE_TYPES.FUNCTION) {
+		if (!config.supportsFunctions) return "";
+		const args = value.arguments || [];
+		const getArgValue = (arg) => {
+			return cleanQuotes(arg.type === AST_NODE_TYPES.LITERAL ? String(arg.value) : String(arg));
+		};
+		if (value.name === FUNCTION_NAMES.MEMBERS_OF) {
+			if (args.length > 0) return `${value.name}(${getArgValue(args[0])})`;
+			return `${value.name}()`;
+		}
+		if (value.name === FUNCTION_NAMES.CASCADE_OPTION && args.length > 0) {
+			var _config$valueMap;
+			const argValue = getArgValue(args[0]);
+			if ((_config$valueMap = config.valueMap) === null || _config$valueMap === void 0 ? void 0 : _config$valueMap[argValue]) return `"${config.valueMap[argValue]}"`;
+			return `"${argValue}"`;
+		}
+		return `"${value.name}()"`;
+	}
+	if (value.type === AST_NODE_TYPES.LITERAL) {
+		var _config$valueMap2;
+		let val = cleanQuotes(String(value.value));
+		if ((_config$valueMap2 = config.valueMap) === null || _config$valueMap2 === void 0 ? void 0 : _config$valueMap2[val]) {
+			const mappedValue = config.valueMap[val];
+			val = Array.isArray(mappedValue) ? mappedValue[0] : mappedValue;
+		}
+		if (config.isNumeric) {
+			const numValue = parseFloat(val);
+			if (!isNaN(numValue) && numValue < 0) return "";
+			return val;
+		}
+		return `"${val}"`;
+	}
+	return "";
+}
+/**
+* 通用的等值操作符处理（= 和 !=）
+* @param operator 操作符
+* @param value 值节点
+* @param config 转换配置
+* @returns IQL 查询字符串
+*/
+function handleEqualityOperator(operator, value, config) {
+	const normalizedOp = operator.toLowerCase();
+	if (normalizedOp !== COMPARISON_OPERATORS.EQUAL && normalizedOp !== COMPARISON_OPERATORS.NOT_EQUAL) return "";
+	if (value.type === AST_NODE_TYPES.LITERAL) {
+		const val = String(value.value);
+		if (config.handleEmpty && val.toUpperCase() === NULL_KEYWORDS.EMPTY) {
+			const nullOp = normalizedOp === "=" ? "is" : "is not";
+			const nullKeyword = config.nullKeyword || "null";
+			return `"${config.iqlFieldName}" ${nullOp} ${nullKeyword}`;
+		}
+		if (config.useInForEquality && config.valueMap) {
+			const cleanVal = cleanQuotes(val);
+			const mappedValue = config.valueMap[cleanVal];
+			const valuesStr = (mappedValue ? Array.isArray(mappedValue) ? mappedValue : [mappedValue] : [cleanVal]).map((v) => `"${v}"`).join(", ");
+			const inOp = normalizedOp === "=" ? "in" : "not in";
+			return `"${config.iqlFieldName}" ${inOp} [${valuesStr}]`;
+		}
+		const convertedValue = convertValue(value, config);
+		if (convertedValue) return `"${config.iqlFieldName}" ${normalizedOp} ${convertedValue}`;
+	}
+	if (value.type === AST_NODE_TYPES.FUNCTION && config.supportsFunctions) {
+		const convertedValue = convertValue(value, config);
+		return `"${config.iqlFieldName}" ${normalizedOp} ${convertedValue}`;
+	}
+	return "";
+}
+/**
+* 通用的比较操作符处理（>, >=, <, <=）
+* @param operator 操作符
+* @param value 值节点
+* @param config 转换配置
+* @returns IQL 查询字符串
+*/
+function handleComparisonOperator(operator, value, config) {
+	const normalizedOp = operator.toLowerCase();
+	if (![
+		COMPARISON_OPERATORS.GREATER_THAN,
+		COMPARISON_OPERATORS.GREATER_THAN_OR_EQUAL,
+		COMPARISON_OPERATORS.LESS_THAN,
+		COMPARISON_OPERATORS.LESS_THAN_OR_EQUAL
+	].includes(normalizedOp)) return "";
+	if (value.type === AST_NODE_TYPES.LITERAL) {
+		const convertedValue = convertValue(value, config);
+		if (convertedValue) return `"${config.iqlFieldName}" ${normalizedOp} ${convertedValue}`;
+	}
+	return "";
+}
+/**
+* 通用的 IN/NOT IN 操作符处理
+* @param operator 操作符
+* @param value 值节点（应该是 List 类型或 Function 类型）
+* @param config 转换配置
+* @returns IQL 查询字符串
+*/
+function handleInOperator(operator, value, config) {
+	const normalizedOp = operator.toLowerCase();
+	if (normalizedOp !== SET_OPERATORS.IN && normalizedOp !== SET_OPERATORS.NOT_IN) return "";
+	if (value.type === AST_NODE_TYPES.FUNCTION && config.supportsFunctions) {
+		const convertedValue = convertValue(value, config);
+		if (convertedValue) return `"${config.iqlFieldName}" ${normalizedOp} [${convertedValue}]`;
+	}
+	if (value.type === AST_NODE_TYPES.LIST) {
+		const emptyElements = [];
+		const nonEmptyElements = [];
+		for (const el of value.elements) {
+			if (!config.supportsFunctions && el.type === AST_NODE_TYPES.FUNCTION) continue;
+			if (config.handleEmpty && el.type === AST_NODE_TYPES.LITERAL && /^empty$/i.test(String(el.value))) emptyElements.push(el);
+			else nonEmptyElements.push(el);
+		}
+		const conditions = [];
+		if (nonEmptyElements.length > 0) {
+			const allValues = [];
+			for (const el of nonEmptyElements) if (el.type === AST_NODE_TYPES.LITERAL) {
+				var _config$valueMap3;
+				const cleanVal = cleanQuotes(String(el.value));
+				const mappedValue = (_config$valueMap3 = config.valueMap) === null || _config$valueMap3 === void 0 ? void 0 : _config$valueMap3[cleanVal];
+				if (mappedValue) {
+					const values = Array.isArray(mappedValue) ? mappedValue : [mappedValue];
+					allValues.push(...values.map((v) => `"${v}"`));
+				} else {
+					const convertedValue = convertValue(el, config);
+					if (convertedValue) allValues.push(convertedValue);
+				}
+			} else {
+				const convertedValue = convertValue(el, config);
+				if (convertedValue) allValues.push(convertedValue);
+			}
+			if (allValues.length > 0) conditions.push(`"${config.iqlFieldName}" ${normalizedOp} [${allValues.join(", ")}]`);
+		}
+		if (emptyElements.length > 0) {
+			const nullOp = normalizedOp === SET_OPERATORS.IN ? NULL_OPERATORS.IS : NULL_OPERATORS.IS_NOT;
+			const nullKeyword = config.nullKeyword || NULL_KEYWORDS.NULL;
+			conditions.push(`"${config.iqlFieldName}" ${nullOp} ${nullKeyword}`);
+		}
+		if (conditions.length > 1) {
+			const connector = normalizedOp === SET_OPERATORS.IN ? IQL_LOGICAL_OPERATORS.OR : IQL_LOGICAL_OPERATORS.AND;
+			return `(${conditions.join(` ${connector} `)})`;
+		} else if (conditions.length === 1) return conditions[0];
+	}
+	return "";
+}
+/**
+* 通用的 IS/IS NOT 操作符处理
+* @param operator 操作符
+* @param value 值节点
+* @param config 转换配置
+* @returns IQL 查询字符串
+*/
+function handleIsOperator(operator, value, config) {
+	const normalizedOp = operator.toLowerCase();
+	if ((normalizedOp === "is" || normalizedOp === "is not") && value.type === "Literal") {
+		const val = String(value.value).toUpperCase();
+		if (val === "NULL" || val === "EMPTY") {
+			const nullKeyword = config.nullKeyword || "null";
+			return `"${config.iqlFieldName}" ${normalizedOp} ${nullKeyword}`;
+		}
+	}
+	return "";
+}
+/**
+* 通用的模糊匹配操作符处理（~ 和 !~）
+* @param operator 操作符
+* @param value 值节点
+* @param config 转换配置
+* @returns IQL 查询字符串
+*/
+function handleContainsOperator(operator, value, config) {
+	const normalizedOp = operator.toLowerCase();
+	if ((normalizedOp === "~" || normalizedOp === "!~") && value.type === "Literal") {
+		const convertedValue = convertValue(value, config);
+		if (convertedValue) return `"${config.iqlFieldName}" ${normalizedOp} ${convertedValue}`;
+	}
+	return "";
+}
+/**
+* 通用字段转换器
+* @param fieldName 字段名
+* @param operator 操作符
+* @param value 值节点
+* @param constantsMap 常量映射
+* @param options 额外选项
+* @returns IQL 查询字符串
+*/
+function convertGenericField(fieldName, operator, value, constantsMap, options = {}) {
+	const fieldConfig = (constantsMap.fieldMap || {})[normalizeFieldName(fieldName)];
+	const config = {
+		iqlFieldName: (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.customFieldKey) || fieldName,
+		supportsFunctions: options.supportsFunctions || false,
+		valueMap: options.valueMapKey ? constantsMap[options.valueMapKey] : void 0,
+		isNumeric: options.isNumeric || false,
+		handleEmpty: options.handleEmpty || false,
+		nullKeyword: options.nullKeyword || "null",
+		useInForEquality: options.useInForEquality || false
+	};
+	const normalizedOp = operator.toLowerCase();
+	if (normalizedOp === "=" || normalizedOp === "!=") return handleEqualityOperator(operator, value, config);
+	if ([
+		">",
+		">=",
+		"<",
+		"<="
+	].includes(normalizedOp)) return handleComparisonOperator(operator, value, config);
+	if (normalizedOp === "in" || normalizedOp === "not in") return handleInOperator(operator, value, config);
+	if (normalizedOp === "is" || normalizedOp === "is not") return handleIsOperator(operator, value, config);
+	if (normalizedOp === "~" || normalizedOp === "!~") return handleContainsOperator(operator, value, config);
+	return "";
+}
+/**
+* 转换 project 字段
+*/
+function convertProjectField(operator, value, constantsMap) {
+	const projectMap = constantsMap.projectMap || {};
+	if (operator === "=") {
+		if (value.type === "Literal") {
+			const projectKey = String(value.value);
+			return `"所属空间" = "${projectMap[projectKey] || projectKey}"`;
+		}
+	}
+	if (operator === "in") {
+		if (value.type === "List") return `"所属空间" in [${filterFunctions(value.elements).filter((el) => el.type === "Literal").map((el) => {
+			const projectKey = String(el.value);
+			return projectMap[projectKey] || projectKey;
+		}).map((name) => `"${name}"`).join(", ")}]`;
+	}
+	return "";
+}
+/**
+* 转换 issuetype 字段
+*/
+function convertIssuetypeField(operator, value, constantsMap) {
+	if (operator === "=") {
+		if (value.type === "Literal") return `"类型" = "${String(value.value)}"`;
+	}
+	if (operator === "in") {
+		if (value.type === "List") return `"类型" in [${filterFunctions(value.elements).filter((el) => el.type === "Literal").map((el) => `"${String(el.value)}"`).join(",")}]`;
+	}
+	return "";
+}
+/**
+* 转换用户字段
+* @param fieldName JQL 字段名
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射，包含 fieldMap 配置
+*/
+function convertUserField(fieldName, operator, value, constantsMap) {
+	return convertGenericField(fieldName, operator, value, constantsMap, {
+		supportsFunctions: true,
+		handleEmpty: true
+	});
+}
+/**
+* 转换版本字段
+* @param fieldName JQL 字段名
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertVersionField(fieldName, operator, value, constantsMap) {
+	return convertGenericField(fieldName, operator, value, constantsMap, {
+		valueMapKey: "versionMap",
+		handleEmpty: true,
+		nullKeyword: "NULL",
+		useInForEquality: true
+	});
+}
+/**
+* 转换 component 字段（Tree 类型）
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertComponentField(operator, value, constantsMap) {
+	return convertGenericField("所属模块", operator, value, constantsMap, {
+		valueMapKey: "component",
+		handleEmpty: true,
+		nullKeyword: "NULL"
+	});
+}
+/**
+* 转换 Cascade 字段（级联选择）
+* @param fieldName JQL 字段名
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertCascadeField(fieldName, operator, value, constantsMap) {
+	return convertGenericField(fieldName, operator, value, constantsMap, {
+		supportsFunctions: true,
+		valueMapKey: "cascade",
+		handleEmpty: true,
+		nullKeyword: "null"
+	});
+}
+/**
+* 转换状态字段
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertStatusField(operator, value, constantsMap) {
+	if (operator === "=") {
+		if (value.type === "Literal") return `"状态" = "${String(value.value).replace(/^"|"$/g, "")}"`;
+	}
+	if (operator === "in") {
+		if (value.type === "List") return `"状态" in [${filterFunctions(value.elements).filter((el) => el.type === "Literal").map((el) => {
+			return `"${String(el.value).replace(/^"|"$/g, "")}"`;
+		}).join(", ")}]`;
+	}
+	return "";
+}
+/**
+* 转换 Sprint 字段
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertSprintField(operator, value, constantsMap) {
+	if (operator === "=") {
+		if (value.type === "Literal") return `"迭代" = "${String(value.value)}"`;
+	}
+	if (operator === "in") {
+		if (value.type === "List") return `"迭代" in [${filterFunctions(value.elements).filter((el) => el.type === "Literal").map((el) => {
+			return `"${String(el.value)}"`;
+		}).join(", ")}]`;
+	}
+	return "";
+}
+/**
+* 转换 Priority 字段
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertPriorityField(operator, value, constantsMap) {
+	return convertGenericField("优先级", operator, value, constantsMap, { handleEmpty: false });
+}
+/**
+* 转换枚举字段（Checkbox/Dropdown/Radio）
+* @param fieldName JQL 字段名
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertEnumField(fieldName, operator, value, constantsMap) {
+	const fieldConfig = (constantsMap.fieldMap || {})[normalizeFieldName(fieldName)];
+	return convertGenericField(fieldName, operator, value, constantsMap, {
+		handleEmpty: false,
+		valueMapKey: (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.customFieldKey) || fieldName
+	});
+}
+/**
+* 转换 Text/LongText/Name 字段
+* @param fieldName JQL 字段名
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertTextField(fieldName, operator, value, constantsMap) {
+	return convertGenericField(fieldName, operator, value, constantsMap, { handleEmpty: false });
+}
+/**
+* 转换数值字段 (Number/Integer/Float)
+* @param fieldName JQL 字段名
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertNumberField(fieldName, operator, value, constantsMap) {
+	return convertGenericField(fieldName, operator, value, constantsMap, {
+		isNumeric: true,
+		handleEmpty: true,
+		nullKeyword: "null"
+	});
+}
+/**
+* 转换用户组字段值（使用单引号）
+* @param value AST 节点
+* @returns 转换后的字符串值
+*/
+function convertUserGroupValue(value) {
+	if (value.type === "Literal") return `'${cleanQuotes(String(value.value))}'`;
+	return "";
+}
+/**
+* 转换用户组字段 (UserGroup)
+* @param fieldName JQL 字段名
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertUserGroupField(fieldName, operator, value, constantsMap) {
+	const fieldConfig = (constantsMap.fieldMap || {})[normalizeFieldName(fieldName)];
+	const iqlFieldName = (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.customFieldKey) || fieldName;
+	const normalizedOp = operator.toLowerCase();
+	if (normalizedOp === "=" || normalizedOp === "!=") {
+		const convertedValue = convertUserGroupValue(value);
+		if (convertedValue) return `"${iqlFieldName}" ${normalizedOp} ${convertedValue}`;
+		return "";
+	}
+	if (normalizedOp === "in" || normalizedOp === "not in") {
+		if (value.type === "List") {
+			const conditions = [];
+			const values = [];
+			let hasEmpty = false;
+			for (const el of value.elements) if (el.type === "Literal" && String(el.value).toUpperCase() === "EMPTY") hasEmpty = true;
+			else {
+				const convertedValue = convertUserGroupValue(el);
+				if (convertedValue) values.push(convertedValue);
+			}
+			if (values.length > 0) conditions.push(`"${iqlFieldName}" ${normalizedOp} [${values.join(", ")}]`);
+			if (hasEmpty) {
+				const nullOp = normalizedOp === "in" ? "is" : "is not";
+				conditions.push(`"${iqlFieldName}" ${nullOp} null`);
+			}
+			if (conditions.length > 1) {
+				const connector = normalizedOp === "in" ? "or" : "and";
+				return `(${conditions.join(` ${connector} `)})`;
+			} else if (conditions.length === 1) return conditions[0];
+		}
+		return "";
+	}
+	if (normalizedOp === "is" || normalizedOp === "is not") {
+		if (value.type === "Literal") {
+			const val = String(value.value).toUpperCase();
+			if (val === "NULL" || val === "EMPTY") return `"${iqlFieldName}" ${normalizedOp} null`;
+		}
+		return "";
+	}
+	return "";
+}
+/**
+* IQL 支持的日期函数列表
+*/
+const SUPPORTED_DATE_FUNCTIONS = [
+	"startOfDay",
+	"endOfDay",
+	"startOfWeek",
+	"endOfWeek",
+	"startOfMonth",
+	"endOfMonth",
+	"startOfYear",
+	"endOfYear"
+];
+/**
+* 转换日期函数节点
+* @param funcNode 函数节点
+* @returns 转换后的函数字符串，不支持的函数返回空字符串
+*/
+function convertDateFunction(funcNode) {
+	if (funcNode.type !== "Function") return "";
+	const funcName = funcNode.name;
+	if (!SUPPORTED_DATE_FUNCTIONS.includes(funcName)) return "";
+	const args = funcNode.arguments || [];
+	if (args.length === 0) return `${funcName}()`;
+	else if (args.length === 1) {
+		const arg = args[0];
+		return `${funcName}(${typeof arg === "object" && arg !== null && "value" in arg ? arg.value : arg})`;
+	}
+	return "";
+}
+/**
+* 转换日期字段值
+* @param value AST 节点
+* @returns 转换后的字符串值
+*/
+function convertDateValue(value) {
+	if (value.type === "Function") return convertDateFunction(value);
+	if (value.type === "Literal") {
+		const cleanVal = cleanQuotes(String(value.value));
+		const timeUnitMatch = cleanVal.match(/^([+-]?\d+)([mhdw])$/i);
+		if (timeUnitMatch) {
+			const num = parseInt(timeUnitMatch[1], 10);
+			const unit = timeUnitMatch[2].toLowerCase();
+			if (unit === "m" || unit === "h") return "";
+			if (unit === "d") return num === 0 ? "startOfDay()" : `startOfDay(${num})`;
+			if (unit === "w") {
+				const days = num * 7;
+				return days === 0 ? "startOfDay()" : `startOfDay(${days})`;
+			}
+		}
+		return `"${cleanVal}"`;
+	}
+	return "";
+}
+/**
+* 转换日期字段 (Date/createdAt/updatedAt)
+* @param fieldName JQL 字段名
+* @param operator 操作符
+* @param value 值
+* @param constantsMap 常量映射
+*/
+function convertDateField(fieldName, operator, value, constantsMap) {
+	const fieldConfig = (constantsMap.fieldMap || {})[normalizeFieldName(fieldName)];
+	const iqlFieldName = (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.customFieldKey) || fieldName;
+	const normalizedOp = operator.toLowerCase();
+	if (normalizedOp === "=" || normalizedOp === "!=") {
+		const convertedValue = convertDateValue(value);
+		if (convertedValue) return `"${iqlFieldName}" ${normalizedOp} ${convertedValue}`;
+		return "";
+	}
+	if ([
+		">",
+		">=",
+		"<",
+		"<="
+	].includes(normalizedOp)) {
+		const convertedValue = convertDateValue(value);
+		if (convertedValue) return `"${iqlFieldName}" ${normalizedOp} ${convertedValue}`;
+		return "";
+	}
+	if (normalizedOp === "in" || normalizedOp === "not in") {
+		if (value.type === "List") {
+			let hasEmpty = false;
+			const values = [];
+			for (const el of value.elements) if (el.type === "Literal" && String(el.value).toUpperCase() === "EMPTY") hasEmpty = true;
+			else {
+				const convertedValue = convertDateValue(el);
+				if (convertedValue) values.push(convertedValue);
+			}
+			if (hasEmpty && values.length === 0) return `"${iqlFieldName}" ${normalizedOp === "in" ? "is" : "is not"} null`;
+			if (hasEmpty && values.length > 0) {
+				const nullOp = normalizedOp === "in" ? "is" : "is not";
+				return `("${iqlFieldName}" ${normalizedOp} [${values.join(", ")}] or "${iqlFieldName}" ${nullOp} null)`;
+			}
+		}
+		return "";
+	}
+	if (normalizedOp === "is" || normalizedOp === "is not") {
+		if (value.type === "Literal") {
+			const val = String(value.value).toUpperCase();
+			if (val === "NULL" || val === "EMPTY") return `"${iqlFieldName}" ${normalizedOp} null`;
+		}
+		return "";
+	}
+	return "";
+}
+
+//#endregion
+//#region src/ast-to-iql/iql-converter.ts
+/**
+* 验证运算符是否合法
+* @param operator 运算符
+* @param rightNode 右侧节点
+* @returns 是否合法
+*/
+function isValidOperator(operator, rightNode) {
+	const normalizedOp = operator.toLowerCase();
+	const nodeType = rightNode === null || rightNode === void 0 ? void 0 : rightNode.type;
+	const nodeValue = rightNode === null || rightNode === void 0 ? void 0 : rightNode.value;
+	const isNull = nodeType === "Literal" && /^(null|empty)$/i.test(String(nodeValue));
+	switch (normalizedOp) {
+		case COMPARISON_OPERATORS.EQUAL:
+		case COMPARISON_OPERATORS.NOT_EQUAL:
+		case COMPARISON_OPERATORS.GREATER_THAN:
+		case COMPARISON_OPERATORS.GREATER_THAN_OR_EQUAL:
+		case COMPARISON_OPERATORS.LESS_THAN:
+		case COMPARISON_OPERATORS.LESS_THAN_OR_EQUAL:
+		case COMPARISON_OPERATORS.LIKE:
+		case COMPARISON_OPERATORS.NOT_LIKE: return nodeType === AST_NODE_TYPES.LITERAL && !isNull || nodeType === AST_NODE_TYPES.FUNCTION;
+		case SET_OPERATORS.IN:
+		case SET_OPERATORS.NOT_IN: return nodeType === AST_NODE_TYPES.LIST || nodeType === AST_NODE_TYPES.FUNCTION;
+		case NULL_OPERATORS.IS:
+		case NULL_OPERATORS.IS_NOT: return isNull;
+		default: return false;
+	}
+}
+/**
+* 将 AST 节点转换为 IQL 查询字符串
+*/
+function astToIQL(ast, constantsMap) {
+	if (ast.type === AST_NODE_TYPES.BINARY_EXPRESSION) return convertBinaryExpression(ast, constantsMap);
+	if (ast.type === AST_NODE_TYPES.LOGICAL_EXPRESSION) return convertLogicalExpression(ast, constantsMap);
+	if (ast.type === AST_NODE_TYPES.JQL_QUERY) {
+		let result = "";
+		if (ast.where) result = astToIQL(ast.where, constantsMap);
+		if (ast.orderBy) {
+			const orderByClause = convertOrderByClause(ast.orderBy, constantsMap);
+			if (orderByClause) result = result ? `${result} ${orderByClause}` : orderByClause;
+		}
+		return result;
+	}
+	return "";
+}
+const FIELD_TYPE_GROUPS = {
+	user: new Set([
+		"createdBy",
+		"updatedBy",
+		"Assignee",
+		"Reporter",
+		"User"
+	]),
+	version: new Set(["Version", "CustomVersion"]),
+	text: new Set([
+		"Text",
+		"LongText",
+		"Name",
+		"Key"
+	]),
+	number: new Set(["Number", "StoryPoint"]),
+	date: new Set([
+		"Date",
+		"createdAt",
+		"updatedAt"
+	]),
+	enum: new Set([
+		"Checkbox",
+		"Dropdown",
+		"Radio"
+	])
+};
+const SPECIAL_FIELD_HANDLERS = new Map([
+	["project", convertProjectField],
+	["issuetype", convertIssuetypeField],
+	["status", convertStatusField],
+	["component", convertComponentField],
+	["priority", convertPriorityField]
+]);
+/**
+* 转换二元表达式
+*/
+function convertBinaryExpression(expr, constantsMap) {
+	var _expr$left, _constantsMap$fieldMa;
+	let field = (_expr$left = expr.left) === null || _expr$left === void 0 ? void 0 : _expr$left.value;
+	const operator = expr.operator;
+	const right = expr.right;
+	if ((field === null || field === void 0 ? void 0 : field.startsWith("\"")) && field.endsWith("\"")) field = field.slice(1, -1);
+	if (!isValidOperator(operator, right)) return "";
+	const handler = SPECIAL_FIELD_HANDLERS.get(field);
+	if (handler) return handler(operator, right, constantsMap);
+	if (field === "labels") return convertTextField("标签", operator, right, constantsMap);
+	if (field === "sprint" || field === "Sprint") return convertSprintField(operator, right, constantsMap);
+	if (field === "text") return convertTextField("text", operator, right, constantsMap);
+	if (field === "created") return convertDateField("created", operator, right, {
+		...constantsMap,
+		fieldMap: {
+			...constantsMap.fieldMap,
+			created: {
+				objectId: "system-created",
+				customFieldKey: "创建时间",
+				fieldTypeKey: "createdAt"
+			}
+		}
+	});
+	if (field === "updated") return convertDateField("updated", operator, right, {
+		...constantsMap,
+		fieldMap: {
+			...constantsMap.fieldMap,
+			updated: {
+				objectId: "system-updated",
+				customFieldKey: "修改时间",
+				fieldTypeKey: "updatedAt"
+			}
+		}
+	});
+	const normalizedFieldName = normalizeFieldName(field);
+	const fieldConfig = (_constantsMap$fieldMa = constantsMap.fieldMap) === null || _constantsMap$fieldMa === void 0 ? void 0 : _constantsMap$fieldMa[normalizedFieldName];
+	if (!fieldConfig || !(fieldConfig.fieldTypeKey in SUPPORTED_FIELD_TYPES)) return "";
+	const fieldType = fieldConfig.fieldTypeKey;
+	if (FIELD_TYPE_GROUPS.user.has(fieldType)) return convertUserField(field, operator, right, constantsMap);
+	if (FIELD_TYPE_GROUPS.version.has(fieldType)) return convertVersionField(field, operator, right, constantsMap);
+	if (FIELD_TYPE_GROUPS.text.has(fieldType)) return convertTextField(field, operator, right, constantsMap);
+	if (FIELD_TYPE_GROUPS.number.has(fieldType)) return convertNumberField(field, operator, right, constantsMap);
+	if (FIELD_TYPE_GROUPS.date.has(fieldType)) return convertDateField(field, operator, right, constantsMap);
+	if (FIELD_TYPE_GROUPS.enum.has(fieldType)) return convertEnumField(field, operator, right, constantsMap);
+	if (fieldType === "UserGroup") return convertUserGroupField(field, operator, right, constantsMap);
+	if (fieldType === "Cascade") return convertCascadeField(field, operator, right, constantsMap);
+	return "";
+}
+/**
+* 转换 ORDER BY 子句
+*/
+function convertOrderByClause(orderBy, constantsMap) {
+	if (!orderBy || orderBy.type !== AST_NODE_TYPES.ORDER_BY_CLAUSE || !orderBy.fields || orderBy.fields.length === 0) return "";
+	const fieldMap = constantsMap.fieldMap || {};
+	const orderFields = [];
+	for (const orderField of orderBy.fields) {
+		const fieldName = orderField.field;
+		const direction = orderField.direction.toLowerCase();
+		const fieldConfig = fieldMap[normalizeFieldName(fieldName)];
+		const iqlFieldName = (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.customFieldKey) || fieldName;
+		orderFields.push(`${iqlFieldName} ${direction}`);
+	}
+	if (orderFields.length === 0) return "";
+	return `${SQL_CLAUSES.ORDER_BY} ${orderFields.join(",")}`;
+}
+/**
+* 转换逻辑表达式
+*/
+function convertLogicalExpression(expr, constantsMap) {
+	const operator = expr.operator;
+	const left = expr.left ? astToIQL(expr.left, constantsMap) : "";
+	const right = expr.right ? astToIQL(expr.right, constantsMap) : "";
+	if (operator === LOGICAL_OPERATORS.AND) {
+		if (!left || !right) return "";
+		return `${left} ${IQL_LOGICAL_OPERATORS.AND} ${right}`;
+	}
+	if (operator === LOGICAL_OPERATORS.OR) {
+		if (!left || !right) return "";
+		return `${left} ${IQL_LOGICAL_OPERATORS.OR} ${right}`;
+	}
+	if (operator === LOGICAL_OPERATORS.NOT) {
+		if (!left) return "";
+		return `${IQL_LOGICAL_OPERATORS.NOT} ${left}`;
+	}
+	return "";
+}
+
+//#endregion
+//#region src/field-transformer.ts
+/**
+* JQL 系统字段到 IQL 字段的映射
+*/
+const SYSTEM_FIELD_MAPPING = {
+	project: "workspace",
+	creator: "createdBy",
+	created: "createdAt",
+	updated: "updatedAt",
+	assignee: "assignee",
+	reporter: "reporter",
+	status: "status",
+	Sprint: "sprint",
+	priority: "priority",
+	summary: "name",
+	text: "name",
+	key: "key",
+	"Story Points": "StoryPoint",
+	component: "r_module_management_associated_module",
+	labels: "jira_system_labels",
+	description: "jira_system_description",
+	fixVersion: "version",
+	affectedVersion: "jira_system_versions",
+	environment: "jira_system_environment",
+	resolution: "jira_system_resolution"
+};
+/**
+* FieldType ObjectId 到 FieldTypeKey 的映射
+*/
+const FIELD_TYPE_MAPPING = {
+	"NTXX60ceoD": "Name",
+	"na20LzXTA2": "Text",
+	"9SZARgA5TI": "LongText",
+	"4DFeBwRLk9": "LongText",
+	"xCY9ooDKKY": "Number",
+	"CpJDd7io5a": "StoryPoint",
+	"xCv93s1xbd": "Number",
+	"cFdABEFcts": "Date",
+	"euBEAkKOz0": "Date",
+	"xCv93s1xut": "Date",
+	"5nYmdVook2": "Tag",
+	"pgCBxAIJjG": "Dropdown",
+	"3wIfFg5kx4": "Radio",
+	"iW2i992pSp": "Checkbox",
+	"AG5wBe2Ir0": "User",
+	"1g5POUEzw9": "createdBy",
+	"IKeDQI8CrC": "updatedBy",
+	"f59j6P7DhC": "Assignee",
+	"Idh8D5b4sF5": "Reporter",
+	"yCE1bJNxOU": "Version",
+	"809afb6a52": "Version",
+	"an27WsuEID": "UserGroup",
+	"5EXG80C96P": "Cascade",
+	"YE5NQcNDAn": "Priority",
+	"voZko9nkcn": "Status",
+	"rETqSrEpjZ": "Sprint",
+	"EPBm2adxxk": "StatusType",
+	"pN1urEY45D": "Key",
+	"IJ9nXcXYKB": "Workspace",
+	"HBZegUsQdF": "ItemType",
+	"2pvaQp1S5U": "ItemType",
+	"pCHjdxS3Lk": "Tree",
+	"wO2Ei7NTDc": "Tree",
+	"TZwrcPvByG": "File",
+	"DgBnXFOc2P": "Text",
+	"gJxcU0Vy8o": "Number",
+	"pmtLzwTuwd": "Text",
+	"JbI5WXiaFk": "Text",
+	"jGXxAc32dP": "Text"
+};
+/**
+* 创建枚举值映射
+* @param customData 自定义数据数组
+* @param labelKey 标签的键名（'label' 或 'title'）
+* @param inverse 是否反转映射方向（true: value->label, false: label->value）
+*/
+function createValueMap(customData, labelKey = "label", inverse = false) {
+	const map = {};
+	for (const item of customData) {
+		const label = labelKey === "title" ? item.title || item.label : item.label;
+		if (label && item.value) map[inverse ? item.value : label] = inverse ? label : item.value;
+	}
+	return map;
+}
+/**
+* 将映射添加到多个键
+*/
+function addMapToKeys(enumValueMaps, keys, valueMap) {
+	for (const key of keys) enumValueMaps[key] = valueMap;
+}
+/**
+* 将原始字段数组转换为 ConstantsMap 格式
+* 这个函数应该在外部调用一次，然后重复使用返回的 ConstantsMap 进行多次转换
+*
+* @param fields 原始字段数组
+* @param projectMap 项目映射（可选）
+* @param versionMap 版本映射（可选）
+* @returns ConstantsMap 对象，可直接传给 jql2iql 使用
+*/
+function transformFieldsToConstantsMap(fields, projectMap, versionMap) {
+	const fieldMap = {};
+	const enumValueMaps = {};
+	let componentMap;
+	const cascadeMaps = {};
+	for (const field of fields) {
+		const { key, name, objectId, fieldType, data } = field;
+		const fieldTypeKey = FIELD_TYPE_MAPPING[fieldType.objectId] || "Text";
+		const jqlFieldKeys = findJQLFieldKeys(key, name);
+		const fieldInfo = {
+			objectId,
+			customFieldKey: name,
+			fieldTypeKey,
+			fieldTypeId: fieldType.objectId
+		};
+		for (const jqlFieldKey of jqlFieldKeys) fieldMap[jqlFieldKey] = fieldInfo;
+		if (key.startsWith("customfield_")) fieldMap[key.replace("customfield_", "")] = fieldInfo;
+		if ((data === null || data === void 0 ? void 0 : data.customData) && data.customData.length > 0) {
+			const isComponent = key === "r_module_management_associated_module" || name === "所属模块";
+			if (fieldTypeKey === "Cascade") {
+				const valueMap = createValueMap(data.customData, "label", true);
+				addMapToKeys(enumValueMaps, [name, ...jqlFieldKeys], valueMap);
+				Object.assign(cascadeMaps, valueMap);
+			} else if (isComponent) componentMap = createValueMap(data.customData, "title");
+			else {
+				const valueMap = createValueMap(data.customData);
+				if (Object.keys(valueMap).length > 0) addMapToKeys(enumValueMaps, [name, ...jqlFieldKeys], valueMap);
+			}
+		}
+	}
+	return {
+		projectMap,
+		versionMap,
+		component: componentMap,
+		cascade: Object.keys(cascadeMaps).length > 0 ? cascadeMaps : void 0,
+		fieldMap,
+		...enumValueMaps
+	};
+}
+/**
+* 查找字段的 JQL 字段名（可能返回多个，如"标题"同时映射 text 和 summary）
+* 对于系统字段，返回 JQL 标准名称；对于自定义字段，返回字段名或 key
+*/
+function findJQLFieldKeys(key, name) {
+	const nameToJQLMap = {
+		"标题": ["text", "summary"],
+		"负责人": ["assignee"],
+		"创建人": ["creator"],
+		"创建时间": ["created"],
+		"更新人": ["updatedBy"],
+		"报告人": ["reporter"],
+		"优先级": ["priority"],
+		"状态": ["status"],
+		"迭代": ["Sprint"],
+		"所属模块": ["component"],
+		"标签": ["labels"],
+		"描述": ["description"]
+	};
+	if (nameToJQLMap[name]) return nameToJQLMap[name];
+	const matchedKeys = [];
+	for (const [jqlKey, iqlKey] of Object.entries(SYSTEM_FIELD_MAPPING)) if (key === iqlKey) matchedKeys.push(jqlKey);
+	if (matchedKeys.length > 0) return matchedKeys;
+	return [name];
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* 解析 JQL 查询字符串为 AST
+*/
+function parseJQL(jqlText) {
+	return buildAST(new JQLParser(new CommonTokenStream(new JQLLexer(CharStreams.fromString(jqlText)))).jqlQuery());
+}
+/**
+* 将 JQL 转换为 IQL
+*/
+function jql2iql(jqlText, constantsMap) {
+	const ast = parseJQL(jqlText);
+	if (!ast) return "";
+	return astToIQL(ast, constantsMap);
+}
+
+//#endregion
+export { astToIQL, buildAST, getNodeInfo, jql2iql, parseJQL, transformFieldsToConstantsMap, traverseJQLTree };