@lcap/nasl 4.4.0-beta.9 → 4.4.0-rc.2

package/out/natural/transforms/utils.js

@@ -1,714 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addLint = exports.validateParentConstraints = exports.parseParentAcceptDescription = exports.validateComponentFeature = exports.getComponentInfo = exports.getComponentSlot = exports.getComponentEvent = exports.getComponentProp = exports.pickDecoratorObject = exports.checkOQLCalleeNameOrder = exports.fetchFromComments = exports.handleListSort = exports.upgradeListSort = exports.replaceCallFunctionMap = exports.callFunctionMap = exports.tryParseTS = exports.throwWarning = exports.throwError = exports.ParseNaturalTSError = exports.parseNaturalTSErrorMap = exports.DEBUG = exports.generate = exports.naslTypes = exports.babelTypes = void 0;
-const babel = __importStar(require("@babel/core"));
-const babelTypes = __importStar(require("@babel/types"));
-exports.babelTypes = babelTypes;
-const naslTypes = __importStar(require("../../concepts"));
-exports.naslTypes = naslTypes;
-const generator_1 = __importDefault(require("@babel/generator"));
-exports.generate = generator_1.default;
-// Dynamic DEBUG function to allow runtime environment variable changes
-function DEBUG() {
-    return process.env.NATURAL_TS_THROW_ERROR === 'true';
-}
-exports.DEBUG = DEBUG;
-exports.parseNaturalTSErrorMap = {};
-class ParseNaturalTSError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ParseNaturalTSError';
-    }
-}
-exports.ParseNaturalTSError = ParseNaturalTSError;
-/**
- * 抛出错误
- * @param message 错误信息
- * @param babelNode babel节点，用于便捷生成代码片段信息
- * @param babelNode2 babel节点，用于便捷生成代码片段信息
- */
-function throwError(state, message, babelNode, babelNode2) {
-    if (state.nodeNamespace) {
-        let namespaceAndName = `${state.nodeNamespace}.${state.nodeName ? state.nodeName : '*'}`;
-        if (state.nodeName && state.appendExtName) {
-            namespaceAndName += state.nodeNamespace.includes('.views.') ? '.tsx' : '.ts';
-        }
-        message += '\n**可能的位置**: ' + namespaceAndName;
-    }
-    if (babelNode) {
-        let code = typeof babelNode === 'string' ? babelNode : (0, generator_1.default)(babelNode).code;
-        const truncatedCode = code.slice(0, 1000);
-        if (code.length > 1000) {
-            message += '\n**相关代码片段**: ' + truncatedCode + `...(omit ${code.length - 1000} char)`;
-        }
-        else {
-            message += '\n**相关代码片段**: ' + truncatedCode;
-        }
-    }
-    if (babelNode2) {
-        let code = typeof babelNode2 === 'string' ? babelNode2 : (0, generator_1.default)(babelNode2).code;
-        const truncatedCode = code.slice(0, 1000);
-        if (code.length > 1000) {
-            message += '\n**更多代码片段**: ' + truncatedCode + `...(omit ${code.length - 1000} char)`;
-        }
-        else {
-            message += '\n**更多代码片段**: ' + truncatedCode;
-        }
-    }
-    if (!state.parsingId) {
-        throw new ParseNaturalTSError(message);
-    }
-    else {
-        const keys = Object.keys(exports.parseNaturalTSErrorMap).map(Number).sort();
-        keys.forEach((key) => {
-            if (state.parsingId - key > 1000 * 60 * 60)
-                delete exports.parseNaturalTSErrorMap[key];
-        });
-        const errors = exports.parseNaturalTSErrorMap[state.parsingId] = exports.parseNaturalTSErrorMap[state.parsingId] || [];
-        // 相同错误过滤：避免重复的错误信息
-        if (!errors.includes(message)) {
-            errors.push(message);
-        }
-    }
-}
-exports.throwError = throwError;
-/**
- * 抛出警告，在 DEBUG 模式下不抛出这类错误
- * @param message 错误信息
- * @param babelNode babel节点，用于便捷生成代码片段信息
- * @param babelNode2 babel节点，用于便捷生成代码片段信息
- */
-function throwWarning(message, babelNode, babelNode2) {
-    if (DEBUG())
-        return;
-    if (babelNode) {
-        let code = typeof babelNode === 'string' ? babelNode : (0, generator_1.default)(babelNode).code;
-        message += '：' + code.slice(0, 1000);
-    }
-    if (babelNode2) {
-        let code = typeof babelNode2 === 'string' ? babelNode2 : (0, generator_1.default)(babelNode2).code;
-        message += '\n' + code.slice(0, 1000);
-    }
-    throw new Error(message);
-}
-exports.throwWarning = throwWarning;
-function tryParseTS(tsCode) {
-    try {
-        const root = babel.parseSync(tsCode, {
-            filename: 'result.ts',
-            presets: [require('@babel/preset-typescript')],
-        });
-        // console.log((root as any).program.body[0].body.body.map((item) => item.trailingComments));
-        return root;
-    }
-    catch (e) {
-        return null;
-    }
-}
-exports.tryParseTS = tryParseTS;
-exports.callFunctionMap = [
-    'Convert',
-    'FormatNumber',
-    'FormatDateTime',
-    'FormatDate',
-    'FromString',
-    'ToString',
-    'Length',
-    'IndexOf',
-    'Join',
-    'LastIndexOf',
-    'Replace',
-    'Split',
-    'SubString',
-    'ToLower',
-    'ToUpper',
-    'Trim',
-    'CurrDate',
-    'CurrDateTime',
-    'CurrTime',
-    'DateDiff',
-    'AlterDateTime',
-    'GetDateCount',
-    'GetSpecificDaysOfWeek',
-    'ListAdd',
-    'ListAddAll',
-    'ListContains',
-    'ListInsert',
-    'ListDistinct',
-    'ListDistinctBy',
-    'ListFilter',
-    'ListFind',
-    'ListFindIndex',
-    'ListFlatten',
-    'ListGroupBy',
-    'ListHead',
-    'ListLast',
-    'ListMax',
-    'ListMin',
-    'ListReverse',
-    'ListSlice',
-    'ListSort',
-    'ListSum',
-    'ListToMap',
-    'ListTransform',
-    'ListGet',
-    'ListRemove',
-    'ListRemoveAt',
-    'ListSet',
-    'ListRange',
-    'ListRepeat',
-    'MapContains',
-    'MapGet',
-    'MapPut',
-    'MapKeys',
-    'MapRemove',
-    'MapValues',
-    'EnumToList',
-    'EnumItemToText',
-    'Round',
-    'Clear',
-    'Clone',
-    'HasValue',
-    'RandomInt',
-    'NewList',
-    'NewMap',
-    'NewEntity',
-    'NewStructure',
-    'NewAnonymousStructure',
-    'jsonSerialize',
-    'jsonDeserialize',
-    "Add",
-    "AddAll",
-    "Contains",
-    "Insert",
-    "Get",
-    "Remove",
-    "RemoveAt",
-    "Set",
-    "Ceil",
-    "Floor",
-    "Trunc",
-    "TruncDivide",
-    "Abs",
-    "Pow",
-    "Sqrt",
-    "Cbrt",
-    "Log",
-    "PadStart",
-    "PadEnd",
-    "TrimStart",
-    "TrimEnd",
-];
-exports.replaceCallFunctionMap = {
-    "ListAdd": "Add",
-    "ListAddAll": "AddAll",
-    "ListContains": "Contains",
-    "ListInsert": "Insert",
-    "ListGet": "Get",
-    "ListRemove": "Remove",
-    "ListRemoveAt": "RemoveAt",
-    "ListSet": "Set",
-    "COUNTD": "COUNT",
-};
-function upgradeListSort(node) {
-    const asc = node?.arguments?.[2]?.expression;
-    const by = node?.arguments?.[1]?.expression;
-    const newArgument = [
-        {
-            ...node.arguments[0]
-        },
-        {
-            concept: 'Argument',
-            keyword: 'fn1',
-            expression: {
-                concept: 'AnonymousFunction',
-                body: {
-                    concept: 'NewComposite',
-                    typeAnnotation: {
-                        concept: 'TypeAnnotation',
-                        typeKind: 'anonymousStructure',
-                        properties: [
-                            {
-                                concept: 'StructureProperty',
-                                name: 'asc',
-                                typeAnnotation: {
-                                    concept: 'TypeAnnotation',
-                                    typeKind: 'primitive',
-                                    typeNamespace: 'nasl.core',
-                                    typeName: 'Boolean'
-                                }
-                            },
-                            {
-                                concept: 'StructureProperty',
-                                name: 'by',
-                                typeAnnotation: null
-                            }
-                        ]
-                    },
-                    properties: [
-                        {
-                            concept: 'Identifier',
-                            name: 'asc',
-                            folded: false,
-                            typeAnnotation: null
-                        },
-                        {
-                            concept: 'Identifier',
-                            name: 'by',
-                            folded: false,
-                            typeAnnotation: null
-                        }
-                    ],
-                    rights: [
-                        {
-                            concept: 'SelectMembers',
-                            hideMembers: false,
-                            expression: asc,
-                            members: []
-                        }
-                    ],
-                    assignmentLines: [
-                        {
-                            concept: 'AssignmentLine',
-                            leftIndex: [0, 0],
-                            rightIndex: [0]
-                        }
-                    ]
-                },
-                params: by?.params
-            }
-        }
-    ];
-    if (by?.body) {
-        newArgument[1].expression.body.rights.push({
-            concept: 'SelectMembers',
-            hideMembers: false,
-            expression: by.body,
-            members: []
-        });
-        newArgument[1].expression.body.assignmentLines.push({
-            concept: 'AssignmentLine',
-            leftIndex: [0, 1],
-            rightIndex: [1]
-        });
-    }
-    node.arguments = newArgument;
-    return node;
-}
-exports.upgradeListSort = upgradeListSort;
-function handleListSort(node, parseState) {
-    const args = node?.arguments;
-    let hasErrorArg = false;
-    if (args?.[args?.length - 1]?.expression?.concept === 'BooleanLiteral') {
-        if (DEBUG)
-            return throwError(parseState, '调用 ListSort 函数需要使用最新的写法');
-        // 老的 ListSort 结构'nasl.util.ListSort(variable1, (item) => item, true)'，要升级成新的
-        return upgradeListSort(node);
-    }
-    else {
-        args?.forEach((arg, index) => {
-            // 新的 ListSort: nasl.util.ListSort(list, (item) => ({ asc: true, by: item.name}))
-            if (index !== 0) {
-                const argExpression = arg?.expression;
-                if (argExpression?.concept === 'AnonymousFunction' && argExpression?.body?.concept === 'NewComposite') {
-                    // 做下特殊处理
-                    if (argExpression?.body?.rights[1] && argExpression?.body?.rights[1]?.members[0]) {
-                        argExpression.body.rights[1].expression = argExpression?.body?.rights[1]?.members[0];
-                        argExpression.body.rights[1].members = [];
-                        argExpression.body.assignmentLines[1].rightIndex = [1];
-                    }
-                    if (!argExpression?.params?.length) {
-                        argExpression.params = [
-                            {
-                                concept: 'Param',
-                                name: 'item',
-                                typeAnnotation: null
-                            }
-                        ];
-                    }
-                }
-                else if (argExpression?.concept === 'SubLogic') {
-                    hasErrorArg = false;
-                }
-                else {
-                    hasErrorArg = true;
-                }
-            }
-        });
-        if (hasErrorArg)
-            return null;
-        return node;
-    }
-}
-exports.handleListSort = handleListSort;
-function fetchFromComments(comments) {
-    if (!comments || comments.length === 0)
-        return;
-    return comments[0].value.trim();
-}
-exports.fetchFromComments = fetchFromComments;
-const expectedOrder = [
-    "FROM",
-    "JOIN",
-    "WHERE",
-    "GROUP_BY",
-    "SELECT",
-    "HAVING",
-    "ORDER_BY",
-];
-function checkOQLCalleeNameOrder(calleeNames) {
-    let currentIndex = -1;
-    for (const name of calleeNames) {
-        const expectedIndex = expectedOrder.findIndex((item) => name?.includes(item));
-        if (expectedIndex === -1) {
-            // 如果名称不在期望顺序中，返回 false
-            return false;
-        }
-        if (expectedIndex < currentIndex) {
-            // 如果当前名称的索引小于前一个名称的索引，返回 false
-            return false;
-        }
-        currentIndex = expectedIndex;
-    }
-    return true;
-}
-exports.checkOQLCalleeNameOrder = checkOQLCalleeNameOrder;
-function pickDecoratorObject(objectExpression, keys, parseState) {
-    const result = {};
-    objectExpression.properties.forEach((item) => {
-        if (item.type === 'ObjectProperty' && item.key.type === 'Identifier' && keys.has(item.key.name)) {
-            let value;
-            if (item.value.type === 'NullLiteral') {
-                value = null;
-            }
-            else if (item.value.type === 'BooleanLiteral') {
-                value = item.value.value;
-            }
-            else if (item.value.type === 'StringLiteral') {
-                value = item.value.value;
-            }
-            else if (item.value.type === 'NumericLiteral') {
-                value = item.value.value;
-            }
-            else {
-                return throwError(parseState, '不支持的装饰器对象属性值：' + (0, generator_1.default)(item).code);
-            }
-            result[item.key.name] = value;
-        }
-        else {
-            return throwError(parseState, '不支持的装饰器对象属性：' + (0, generator_1.default)(item).code);
-        }
-    });
-    return result;
-}
-exports.pickDecoratorObject = pickDecoratorObject;
-/**
- * 检查组件是否有指定的prop配置
- * @param tagName 组件标签名
- * @param propName 属性名
- * @param lookupMap 查找Map
- * @returns 返回 true 或 false
- */
-function getComponentProp(tagName, propName, lookupMap) {
-    const componentInfo = lookupMap.get(tagName);
-    if (!componentInfo) {
-        // 组件不存在不校验
-        return true;
-    }
-    return !!componentInfo.propsMap.get(propName) || false;
-}
-exports.getComponentProp = getComponentProp;
-/**
- * 检查组件是否有指定的事件配置
- * @param tagName 组件标签名
- * @param eventName 事件名
- * @param lookupMap 查找Map
- * @returns 返回 true 或 false
- */
-function getComponentEvent(tagName, eventName, lookupMap) {
-    const componentInfo = lookupMap.get(tagName);
-    if (!componentInfo) {
-        // 组件不存在不校验
-        return true;
-    }
-    return !!componentInfo.eventsMap.get(eventName) || false;
-}
-exports.getComponentEvent = getComponentEvent;
-/**
- * 检查组件是否有指定的slot配置
- * @param tagName 组件标签名
- * @param slotName 插槽名
- * @param lookupMap 查找Map
- * @returns 返回 true 或 false
- */
-function getComponentSlot(tagName, slotName, lookupMap) {
-    const componentInfo = lookupMap.get(tagName);
-    if (!componentInfo) {
-        // 组件不存在不校验
-        return true;
-    }
-    return !!componentInfo.slotsMap.get(slotName) || false;
-}
-exports.getComponentSlot = getComponentSlot;
-/**
- * 获取组件的完整配置信息
- * @param tagName 组件标签名
- * @param type 查找类型
- * @param lookupMap 查找Map
- * @returns 返回组件配置或null
- */
-function getComponentInfo(tagName, lookupMap, type) {
-    if (type === 'prop') {
-        return lookupMap.get(tagName)?.component?.propsNames || null;
-    }
-    else if (type === 'event') {
-        return lookupMap.get(tagName)?.component?.eventNames || null;
-    }
-    else if (type === 'slot') {
-        return lookupMap.get(tagName)?.component?.slotNames || null;
-    }
-    return lookupMap.get(tagName)?.component || null;
-}
-exports.getComponentInfo = getComponentInfo;
-// 通用白名单
-const COMMON_WHITE_LIST = new Set(['_if', 'destination', 'style', 'class', 'ref', 'widthStretch', 'heightStretch']);
-/**
- * 组件特性校验函数
- * @param tag 组件标签名
- * @param featureType 特性类型
- * @param featureName 特性名称
- * @param attrName 属性名
- * @param options 解析状态选项
- * @param attr JSX属性节点
- */
-function validateComponentFeature(tag, featureType, featureName, options, attr) {
-    if (!options?.componentsMap)
-        return;
-    if (COMMON_WHITE_LIST.has(featureName))
-        return; // 在白名单中，不报错
-    const featureMap = {
-        event: getComponentEvent,
-        slot: getComponentSlot,
-        prop: getComponentProp,
-    };
-    const getFeatureInfo = featureMap[featureType];
-    const hasFeature = getFeatureInfo(tag, featureName, options.componentsMap);
-    if (!hasFeature) {
-        const supportFeatures = getComponentInfo(tag, options.componentsMap, featureType);
-        const featureTypeMap = {
-            event: '事件',
-            slot: '插槽',
-            prop: '属性',
-        };
-        const typeText = featureTypeMap[featureType];
-        const prefix = featureType === 'slot' ? '插槽有：' : featureType === 'prop' ? '属性有：' : '事件列表如下：';
-        // 非严格模式下
-        if (!options.strictForTraining) {
-            // 白名单检查：某些特定组件的特定属性不进行验证
-            if (featureType === 'prop') {
-                const propWhitelist = new Set(['el-table-column:width']);
-                const whitelistKey = `${tag}:${featureName}`;
-                if (propWhitelist.has(whitelistKey)) {
-                    return; // 在白名单中，不报错
-                }
-            }
-        }
-        let explain = '';
-        if (featureType === 'prop' && ['title', 'label'].includes(featureName)) {
-            explain = `, 可能需要使用 slot${naslTypes.firstUpperCase(featureName)}`;
-        }
-        return throwError(options, `组件 ${tag} 不支持${typeText} ${featureName}，当前支持的${prefix}${supportFeatures}${explain}`, attr);
-    }
-}
-exports.validateComponentFeature = validateComponentFeature;
-/**
- * 解析 parentAccept 表达式，生成友好的错误描述
- * @param parentAccept parentAccept 表达式字符串
- * @returns 友好的错误描述字符串
- */
-function parseParentAcceptDescription(parentAccept) {
-    try {
-        // 处理数组的 includes 方法：['el-table'].includes(target.tag)
-        const arrayIncludesMatch = parentAccept.match(/\[([^\]]+)\]\.includes\(target\.tag\)/);
-        if (arrayIncludesMatch) {
-            const items = arrayIncludesMatch[1]
-                .split(',')
-                .map((item) => item.trim().replace(/['"]/g, ''))
-                .filter(Boolean);
-            return items.join(' 或 ');
-        }
-        // 处理单个 endsWith：target.tag.endsWith('el-select')
-        const endsWithMatch = parentAccept.match(/target\.tag\.endsWith\(['"]([^'"]*)['"]\)/);
-        if (endsWithMatch && !parentAccept.includes('||')) {
-            return `以 ${endsWithMatch[1]} 结尾的组件`;
-        }
-        // 处理多个条件用 || 连接的情况
-        if (parentAccept.includes('||')) {
-            const conditions = parentAccept.split('||').map((condition) => condition.trim());
-            const tags = [];
-            for (const condition of conditions) {
-                // 精确匹配：target.tag === 'el-menu'
-                const exactMatch = condition.match(/target\.tag\s*===\s*['"]([^'"]*)['"]/);
-                if (exactMatch) {
-                    tags.push(exactMatch[1]);
-                    continue;
-                }
-                // endsWith 匹配：target.tag.endsWith('el-select')
-                const endsWithMatch = condition.match(/target\.tag\.endsWith\(['"]([^'"]*)['"]\)/);
-                if (endsWithMatch) {
-                    tags.push(`以 ${endsWithMatch[1]} 结尾的组件`);
-                    continue;
-                }
-                // 如果无法解析，添加通用描述
-                tags.push('符合条件的组件');
-            }
-            return tags.join(' 或 ');
-        }
-        // 处理单个精确匹配：target.tag === 'el-carousel'
-        const exactMatch = parentAccept.match(/target\.tag\s*===\s*['"]([^'"]*)['"]/);
-        if (exactMatch) {
-            return exactMatch[1];
-        }
-        // 处理 includes 方法但不是数组形式
-        if (parentAccept.includes('includes(target.tag)')) {
-            return '指定列表中的组件';
-        }
-        // 兜底返回通用描述
-        return '符合条件的父组件';
-    }
-    catch (error) {
-        return '符合条件的父组件';
-    }
-}
-exports.parseParentAcceptDescription = parseParentAcceptDescription;
-// 表单组件变形映射表
-const formComponentMap = {
-    'el-input': 'el-form-input',
-    'el-select': 'el-form-select',
-    'el-cascader': 'el-form-cascader',
-    'el-checkbox-group': 'el-form-checkbox-group',
-    'el-input-number': 'el-form-input-number',
-    'el-input-tag': 'el-form-input-tag',
-    'el-rate': 'el-form-rate',
-    'el-switch': 'el-form-switch',
-    'el-tree-select': 'el-form-tree-select',
-    'el-slider': 'el-form-slider',
-    'el-upload': 'el-form-upload',
-    'el-time-picker': 'el-form-time-picker',
-    'el-time-select': 'el-form-time-select',
-    'el-mention': 'el-form-mention',
-    'el-date-picker': 'el-form-date-picker',
-    'el-transfer': 'el-form-transfer',
-    'el-radio-group': 'el-form-radio-group',
-};
-// 反向映射表，用于从表单组件名获取原始组件名
-const reverseFormComponentMap = {};
-Object.entries(formComponentMap).forEach(([original, form]) => {
-    reverseFormComponentMap[form] = original;
-});
-/**
- * 验证父组件约束
- * @param tag 当前组件标签
- * @param options 解析状态选项
- * @param node JSX节点
- * @returns 如果违反约束则返回错误，否则返回 undefined
- */
-function validateParentConstraints(tag, options, node) {
-    // 检查组件库中的父组件约束
-    if (options.componentsMap) {
-        const componentInfo = getComponentInfo(tag, options.componentsMap);
-        const parentAccept = componentInfo?.ideusage?.parentAccept;
-        if (parentAccept && parentAccept?.includes('target.tag')) {
-            const parentTag = options.parentTag;
-            try {
-                // 创建验证函数来检查父组件是否符合要求
-                const createValidator = (expression, actualParentTag) => {
-                    // 将所有 target.tag 替换为实际的父组件标签
-                    const code = expression.replace(/target\.tag/g, JSON.stringify(actualParentTag || ''));
-                    // 使用 Function 构造器创建验证函数
-                    return new Function('return ' + code)();
-                };
-                let isValidParent = false;
-                let actualParentTag = parentTag;
-                if (parentTag) {
-                    // 首先尝试用原始父组件标签验证
-                    isValidParent = createValidator(parentAccept, parentTag);
-                    // 如果验证失败，尝试使用对应的表单组件或原始组件进行验证
-                    if (!isValidParent) {
-                        // 如果当前父组件是表单组件，尝试用对应的原始组件验证
-                        if (reverseFormComponentMap[parentTag]) {
-                            const originalParentTag = reverseFormComponentMap[parentTag];
-                            isValidParent = createValidator(parentAccept, originalParentTag);
-                            if (isValidParent) {
-                                actualParentTag = originalParentTag;
-                            }
-                        }
-                        // 如果当前父组件是原始组件，尝试用对应的表单组件验证
-                        else if (formComponentMap[parentTag]) {
-                            const formParentTag = formComponentMap[parentTag];
-                            isValidParent = createValidator(parentAccept, formParentTag);
-                            if (isValidParent) {
-                                actualParentTag = formParentTag;
-                            }
-                        }
-                    }
-                }
-                else {
-                    isValidParent = false;
-                }
-                if (parentTag && !isValidParent) {
-                    // 解析 parentAccept 来生成更友好的错误信息
-                    const expectedDescription = parseParentAcceptDescription(parentAccept);
-                    return throwError(options, `组件 ${tag} 必须放在 ${expectedDescription} 内部，但当前父组件是 ${parentTag}`, node);
-                }
-                else if (!parentTag) {
-                    return throwError(options, `组件 ${tag} 必须放在指定的父组件内部`, node);
-                }
-            }
-            catch (error) {
-                console.log(`组件 ${tag} 的 parentAccept 表达式无效: ${parentAccept}`);
-            }
-        }
-    }
-}
-exports.validateParentConstraints = validateParentConstraints;
-/**
- * 在 strictForTraining 模式下执行 lint 检查逻辑
- * 当 options.strictForTraining 为 true 时，执行传入的检查函数
- * @param rule LintRule 对象，包含 name 和可选的 description
- * @param options 解析状态选项
- * @param lintFn 需要执行的 lint 检查函数
- */
-function addLint(options, rule, lintFn) {
-    if (options.strictForTraining) {
-        lintFn(rule);
-    }
-}
-exports.addLint = addLint;
-//# sourceMappingURL=utils.js.map