@nasl/cli 0.1.18 → 0.2.0

package/dist/bin/naslc.mjs

@@ -8308,26 +8308,29 @@ function loadConfig(configDir) {
             defaultLogger.error('配置文件格式不正确，缺少必需的 srcDir 或 outDir 字段');
             return defaultLogger.exit(1);
         }
+        // 环境变量优先级高于配置文件
+        // ideVersion: 环境变量优先，如果都没有则报错
+        if (process.env.NASL_IDE_VERSION)
+            config.ideVersion = process.env.NASL_IDE_VERSION;
         if (!config.ideVersion) {
-            config.ideVersion = process.env.NASL_IDE_VERSION || '';
-            if (!config.ideVersion) {
-                defaultLogger.error('缺少配置 ideVersion，请在配置文件中添加，或在环境变量中配置 NASL_IDE_VERSION');
-                return defaultLogger.exit(1);
-            }
+            defaultLogger.error('缺少配置 ideVersion，请在配置文件中添加，或在环境变量中配置 NASL_IDE_VERSION');
+            return defaultLogger.exit(1);
         }
+        // serverBaseURL: 环境变量优先，如果都没有则报错
+        if (process.env.NASL_SERVER_BASE_URL)
+            config.serverBaseURL = process.env.NASL_SERVER_BASE_URL;
         if (!config.serverBaseURL) {
-            config.serverBaseURL = process.env.NASL_SERVER_BASE_URL || '';
-            if (!config.serverBaseURL) {
-                defaultLogger.error('缺少配置 serverBaseURL，请在配置文件中添加，或在环境变量中配置 NASL_SERVER_BASE_URL');
-                return defaultLogger.exit(1);
-            }
+            defaultLogger.error('缺少配置 serverBaseURL，请在配置文件中添加，或在环境变量中配置 NASL_SERVER_BASE_URL');
+            return defaultLogger.exit(1);
         }
-        if (!config.useOPENAPI)
+        // 环境变量优先
+        if (process.env.USE_LCAP_OPENAPI !== undefined)
             config.useOPENAPI = process.env.USE_LCAP_OPENAPI === 'true';
-        if (!config.OPENAPI_AK)
+        if (process.env.LCAP_OPENAPI_AK)
             config.OPENAPI_AK = process.env.LCAP_OPENAPI_AK;
-        if (!config.OPENAPI_SK)
+        if (process.env.LCAP_OPENAPI_SK)
             config.OPENAPI_SK = process.env.LCAP_OPENAPI_SK;
+        // 如果启用了 OpenAPI，验证必需的 AK 和 SK
         if (config.useOPENAPI) {
             if (!config.OPENAPI_AK || !config.OPENAPI_SK) {
                 defaultLogger.error(`配置了 useOPENAPI，但缺少配置 OPENAPI_AK 和 OPENAPI_SK:
@@ -29142,6 +29145,56 @@ function createSorter() {
     };
 }
 const sorter = createSorter();
+/**
+ * 验证 variables 文件
+ */
+function validateVariablesFile(file, errors) {
+    const matchArr = Array.from(file.content.matchAll(/^(export\s+)(declare\s+)?(const|let)\s+(\w+)/gm));
+    if (matchArr.length === 0) {
+        errors.push(`${file.path} (variables文件) 必须包含至少一个 export const 或 export let 声明`);
+    }
+    for (const match of matchArr) {
+        const [, isExport] = match;
+        if (!isExport)
+            errors.push(`${file.path} 所有声明必须使用 export，错误代码：${match[0]}`);
+    }
+}
+/**
+ * 验证 extensions 文件
+ */
+function validateExtensionsFile(file, errors) {
+    const matchArr = Array.from(file.content.matchAll(/^(export\s+)(namespace)\s+(\w+)/gm));
+    if (matchArr.length === 0) {
+        errors.push(`${file.path} (extensions文件) 必须包含至少一个 export namespace 声明`);
+    }
+    for (const match of matchArr) {
+        const [, isExport] = match;
+        if (!isExport)
+            errors.push(`${file.path} 所有 namespace 必须使用 export，错误代码：${match[0]}`);
+    }
+}
+/**
+ * 验证普通文件（枚举、实体、数据结构、逻辑、页面）
+ */
+function validateNormalFile(file, nameFromPath, namespace, errors) {
+    const matchArr = Array.from(file.content.matchAll(/^(export\s+)?(declare\s+)?(function|class|interface)\s+(\w+)/gm));
+    if (matchArr.length === 0)
+        errors.push(`${file.path} 必须有一个函数或类，错误代码：${file.content}`);
+    else if (matchArr.length > 1)
+        errors.push(`${file.path} 只能有一个函数或类，错误代码：${matchArr.map((match) => match[0]).join('\n')}
+你可以将该文件中所有函数合并，或者将其他函数拆到多个文件中。`);
+    for (const match of matchArr) {
+        const [, isExport, isDeclare, type, name] = match;
+        if (!isExport)
+            errors.push(`${file.path} 必须使用 export，错误代码：${match[0]}`);
+        if (name !== nameFromPath)
+            errors.push(`${file.path} 的函数或类名必须与文件名一致，错误代码：${match[0]}`);
+        if (/\.(entities|enums|structures)/.test(namespace) && type !== 'class')
+            errors.push(`${file.path} 实体、数据结构和枚举只能使用 class 定义，错误代码：${match[0]}`);
+        if (/\.(logics|views)/.test(namespace) && type !== 'function')
+            errors.push(`${file.path} 逻辑和页面只能使用 function 定义，错误代码：${match[0]}`);
+    }
+}
 function composeToString(files) {
     files.sort((a, b) => sorter(a.path, b.path));
     const errors = [];
@@ -29149,28 +29202,31 @@ function composeToString(files) {
         const arr = file.path.split('.');
         const ext = arr.pop();
         const nameFromPath = arr.pop();
-        const namespace = arr.join('.');
+        // 判断是否是特殊文件类型（variables 或 extensions）
+        const isVariablesFile = nameFromPath === 'variables';
+        const isExtensionsFile = arr[0] === 'extensions';
+        const isThemeCss = ext === 'css' && nameFromPath === 'theme';
+        const isSpecialFile = isVariablesFile || isExtensionsFile || isThemeCss;
+        // 特殊文件的 namespace 包含文件名，普通文件不包含
+        const namespace = isSpecialFile ? [...arr, nameFromPath].join('.') : arr.join('.');
+        let content = file.content;
         if (['ts', 'tsx'].includes(ext)) {
-            const matchArr = Array.from(file.content.matchAll(/^(export\s+)?(declare\s+)?(function|class|interface)\s+(\w+)/gm));
-            if (matchArr.length === 0)
-                errors.push(`${file.path} 必须有一个函数或类，错误代码：${file.content}`);
-            else if (matchArr.length > 1)
-                errors.push(`${file.path} 只能有一个函数或类，错误代码：${matchArr.map((match) => match[0]).join('\n')}
-你可以将该文件中所有函数合并，或者将其他函数拆到多个文件中。`);
-            for (const match of matchArr) {
-                const [, isExport, isDeclare, type, name] = match;
-                if (!isExport)
-                    errors.push(`${file.path} 必须使用 export，错误代码：${match[0]}`);
-                if (name !== nameFromPath)
-                    errors.push(`${file.path} 的函数或类名必须与文件名一致，错误代码：${match[0]}`);
-                if (/\.(entities|enums|structures)/.test(namespace) && type !== 'class')
-                    errors.push(`${file.path} 实体、数据结构和枚举只能使用 class 定义，错误代码：${match[0]}`);
-                if (/\.(logics|views)/.test(namespace) && type !== 'function')
-                    errors.push(`${file.path} 逻辑和页面只能使用 function 定义，错误代码：${match[0]}`);
+            if (isVariablesFile) {
+                validateVariablesFile(file, errors);
             }
+            else if (isExtensionsFile) {
+                validateExtensionsFile(file, errors);
+            }
+            else {
+                validateNormalFile(file, nameFromPath, namespace, errors);
+            }
+        }
+        else if (isThemeCss) {
+            content = `  $theme\`${content}\`;`;
         }
-        return `namespace ${namespace} {\n${file.content}\n}\n`;
-    }).join('\n');
+        return `namespace ${namespace} {\n${content}\n}\n`;
+    })
+        .join('\n');
     if (errors.length > 0) {
         throw new Error(errors.join('\n============\n'));
     }
@@ -37691,13 +37747,116 @@ function requireGlobby () {
 var globbyExports = requireGlobby();
 var globby = /*@__PURE__*/getDefaultExportFromCjs(globbyExports);
 
+/**
+ * NASL 支持的所有文件类型配置
+ */
+const NASL_FILE_TYPES = [
+    {
+        name: 'theme-css',
+        description: '主题样式',
+        fileNamePattern: 'app\\.frontendTypes\\.pc\\.frontends\\.pc\\.theme\\.css',
+        codeRefPattern: 'app\\.frontendTypes\\.pc\\.frontends\\.pc\\.theme',
+        extension: 'css',
+    },
+    {
+        name: 'structures',
+        description: '数据结构',
+        fileNamePattern: 'app\\.structures\\.\\w+\\.ts',
+        codeRefPattern: 'app\\.structures\\.\\w+(?:\\.\\w+)*',
+        extension: 'ts',
+    },
+    {
+        name: 'entities',
+        description: '实体',
+        fileNamePattern: 'app\\.dataSources\\.\\w+\\.entities\\.\\w+\\.ts',
+        codeRefPattern: 'app\\.dataSources\\.\\w+\\.entities\\.\\w+(?:Entity)?(?:\\.\\w+)*',
+        extension: 'ts',
+    },
+    {
+        name: 'logics',
+        description: '逻辑',
+        fileNamePattern: 'app\\.logics\\.\\w+\\.ts',
+        codeRefPattern: 'app\\.logics\\.\\w+(?:\\.\\w+)*',
+        extension: 'ts',
+    },
+    {
+        name: 'views',
+        description: '视图',
+        fileNamePattern: 'app\\.frontendTypes\\.\\w+\\.frontends\\.\\w+(?:\\.views\\.\\w+)+\\.tsx',
+        codeRefPattern: 'app\\.frontendTypes\\.\\w+\\.frontends\\.\\w+(?:\\.views\\.\\w+)+(?:\\.\\w+)*',
+        extension: 'tsx',
+    },
+    {
+        name: 'backend-variables',
+        description: '后端全局变量',
+        fileNamePattern: 'app\\.backend\\.variables\\.ts',
+        codeRefPattern: 'app\\.backend\\.variables(?:\\.\\w+)*',
+        extension: 'ts',
+    },
+    {
+        name: 'frontend-variables',
+        description: '前端全局变量',
+        fileNamePattern: 'app\\.frontendTypes\\.\\w+\\.frontends\\.\\w+\\.variables\\.ts',
+        codeRefPattern: 'app\\.frontendTypes\\.\\w+\\.frontends\\.\\w+\\.variables(?:\\.\\w+)*',
+        extension: 'ts',
+    },
+    {
+        name: 'enums',
+        description: '枚举',
+        fileNamePattern: 'app\\.enums\\.\\w+\\.ts',
+        codeRefPattern: 'app\\.enums\\.\\w+(?:\\.\\w+)*',
+        extension: 'ts',
+    },
+    {
+        name: 'extensions',
+        description: '依赖库',
+        fileNamePattern: 'extensions\\.\\w+\\.ts',
+        codeRefPattern: 'extensions\\.\\w+(?:\\.\\w+)*',
+        extension: 'ts',
+    },
+];
+/**
+ * 获取用于验证文件名的正则表达式数组
+ */
+function getFileNamePatterns() {
+    return NASL_FILE_TYPES.map((type) => new RegExp(`^${type.fileNamePattern}$`));
+}
+const fileNamePatterns = getFileNamePatterns();
+/**
+ * 获取用于提取代码引用的正则表达式数组
+ */
+function getCodeRefPatterns() {
+    return NASL_FILE_TYPES.map((type) => new RegExp(type.codeRefPattern, 'g'));
+}
+const codeRefPatterns = getCodeRefPatterns();
+/**
+ * 判断文件路径是否为已知的 NASL 文件类型
+ * 支持的类型：
+ * - 数据结构 (structures): app.structures.{StructureName}.ts
+ * - 实体 (entities): app.dataSources.{dsName}.entities.{EntityName}.ts
+ * - 逻辑 (logics): app.logics.{logicName}.ts
+ * - 视图 (views): app.frontendTypes.{type}.frontends.{name}.views.{viewName}.tsx
+ * - 后端全局变量: app.backend.variables.ts
+ * - 前端全局变量: app.frontendTypes.{type}.frontends.{name}.variables.ts
+ * - 枚举 (enums): app.enums.{EnumName}.ts
+ * - 依赖库 (extensions): extensions.{extensionName}.ts
+ *
+ * @param filePath 文件路径（绝对路径或相对路径）
+ * @returns 是否为已知的 NASL 文件类型
+ */
+function isKnownFileType(filePath) {
+    // 提取文件名
+    const fileName = sysPath.basename(filePath);
+    return fileNamePatterns.some((pattern) => pattern.test(fileName));
+}
+
 /**
  * 扫描目录下的所有 NASL 文件
  */
 async function scanNASLFiles(srcDir, representation, logger) {
     try {
         const pattern = representation === 'NaturalTS' ? '**/*.{ts,tsx}' : '**/*.nasl';
-        const files = await globby([pattern, '!**/*.css'], {
+        const files = await globby([pattern, '**/app.frontendTypes.pc.frontends.pc.theme.css'], {
             cwd: srcDir,
             onlyFiles: true,
             absolute: false,
@@ -37711,7 +37870,6 @@ async function scanNASLFiles(srcDir, representation, logger) {
 }
 async function scanEntryFiles(projectRoot, patterns, logger) {
     try {
-        patterns.push('!**/*.css');
         const files = await globby(patterns, {
             cwd: projectRoot,
             onlyFiles: true,
@@ -37725,30 +37883,46 @@ async function scanEntryFiles(projectRoot, patterns, logger) {
     }
 }
 /**
- * 从文件内容中提取 app.* 格式的依赖引用
+ * 从文件内容中提取 指定 格式的依赖引用
  * @param content 文件内容
- * @returns 依赖的 app.* 路径列表
+ * @returns 依赖的 指定 路径列表
  */
 function extractDeps(content) {
     const deps = new Set();
-    // 预处理：移除注释，避免注释影响依赖分析
+    // 预处理：移除注释和字符串字面量，避免它们影响依赖分析
     let processedContent = content
         .replace(/\/\/.*$/gm, '') // 移除单行注释 // ...
-        .replace(/\/\*[\s\S]*?\*\//g, ''); // 移除多行注释 /* ... */
-    const allMatches = processedContent.matchAll(/app\.\w+\.[\w.]+/g); // 起码要2个点
-    for (const match of allMatches) {
-        let dep = match[0];
-        if (/Entity$|Entity\./.test(dep)) {
-            dep = dep.replace(/Entity(\..*)?$/, '');
-        }
-        else if (/\.enums\.(\w+)\.(\w+)/.test(dep)) {
-            dep = dep.replace(/\.enums\.(\w+).+$/, '.enums.$1');
-        }
-        else if (/app\.dataSources\.\w+\.entities\.\w+\.\w+$/.test(dep)) {
-            continue; // 应该是写法有问题，跳过让后面的 checker 做检查
+        .replace(/\/\*[\s\S]*?\*\//g, '') // 移除多行注释 /* ... */
+        .replace(/'(?:[^'\\]|\\.)*'/g, '') // 移除单引号字符串 'xxx'
+        .replace(/"(?:[^"\\]|\\.)*"/g, ''); // 移除双引号字符串 "xxx"
+    for (const pattern of codeRefPatterns) {
+        const matches = processedContent.matchAll(pattern);
+        for (const match of matches) {
+            let dep = match[0];
+            // 处理 Entity 后缀：app.dataSources.ds.entities.EntityNameEntity -> app.dataSources.ds.entities.EntityName
+            if (/Entity$|Entity\./.test(dep)) {
+                dep = dep.replace(/Entity(\..*)?$/, '');
+            }
+            // 处理枚举：app.enums.EnumName.field -> app.enums.EnumName
+            if (/^app\.enums\.\w+\./.test(dep)) {
+                dep = dep.replace(/^(app\.enums\.\w+).+$/, '$1');
+            }
+            // 处理 variables：app.backend.variables.varName -> app.backend.variables
+            if (/\.variables\.\w+/.test(dep)) {
+                dep = dep.replace(/\.variables\..+$/, '.variables');
+            }
+            // 处理 extensions：extensions.lcap_auth.logics.getUser -> extensions.lcap_auth
+            if (/^extensions\.\w+\./.test(dep)) {
+                dep = dep.replace(/^(extensions\.\w+)\..+$/, '$1');
+            }
+            // 跳过不合法的实体引用（实体后还有字段的情况）
+            if (/app\.dataSources\.\w+\.entities\.\w+\.\w+$/.test(dep)) {
+                continue;
+            }
+            // 添加文件扩展名
+            dep = `${dep}.${dep.includes('.views.') ? 'tsx' : 'ts'}`;
+            deps.add(dep);
         }
-        dep = `${dep}.${dep.includes('.views.') ? 'tsx' : 'ts'}`;
-        deps.add(dep);
     }
     return Array.from(deps);
 }
@@ -37865,7 +38039,12 @@ async function collectDeps(patterns, projectRoot, srcDir, logger, verbose) {
     while (filesToProcess.length > 0) {
         const pathRelativeToSrc = filesToProcess.shift();
         if (processedFileMap.has(pathRelativeToSrc))
-            continue; // 跳过已处理的文件        
+            continue; // 跳过已处理的文件
+        // 检查文件类型是否支持
+        if (!isKnownFileType(pathRelativeToSrc)) {
+            logger.warn(`跳过不支持的文件类型: ${pathRelativeToSrc}`);
+            continue;
+        }
         try {
             const { fileInfo, newDeps } = processFileDeps(pathRelativeToSrc, srcDir, matchedFileSet, processedFileMap, depNotFoundList, logger, verbose);
             result.push(fileInfo);
@@ -37943,8 +38122,18 @@ async function resolveNASLFiles(entry, logger, depMode, verbose) {
         }
         logger.info(`找到 ${collectedFiles.length} 个 NASL 文件`);
     }
+    // 统一过滤掉不支持的文件类型
+    const filteredFiles = [];
+    collectedFiles.forEach((file) => {
+        if (isKnownFileType(file.path)) {
+            filteredFiles.push(file);
+        }
+        else {
+            logger.warn(`跳过不支持的文件类型: ${file.path}`);
+        }
+    });
     return {
-        collectedFiles,
+        collectedFiles: filteredFiles,
         config,
         projectRoot,
         srcDir,
@@ -37993,7 +38182,7 @@ async function tryCompile(entry, options) {
     }
 }
 
-var version = "0.1.18";
+var version = "0.2.0";
 var pkg = {
 	version: version};