@nasl/cli 0.1.19 → 0.2.1

package/dist/bin/nasl.mjs

@@ -8419,23 +8419,6 @@ function writeFileWithLog(filePath, content, logger) {
         throw error;
     }
 }
-/**
- * 判断文件路径是否为已知的 NASL 文件类型
- * 支持的类型：
- * - 枚举 (enums)
- * - 实体 (entities)
- * - 数据结构 (structures)
- * - 逻辑 (logics)
- * - 页面 (views)
- * - 前端/服务端全局变量 (variables)
- * - 依赖库 (extensions)
- */
-function isKnownFileType(filePath) {
-    return (/\.(enums|entities|structures|logics|views)\.\w+\.(ts|tsx)$/.test(filePath) || // 枚举、实体、数据结构、逻辑、页面
-        /^app\..*\.variables\.ts$/.test(filePath) || // 前端/服务端全局变量 (以app开头，以variables.ts结尾)
-        /^extensions\.\w+\.(ts|tsx)$/.test(filePath) // 依赖库
-    );
-}
 
 /**
  * 初始化命令 - 创建配置文件
@@ -29220,9 +29203,10 @@ async function checkApi(fullNaturalTS, options) {
     });
     const result = res.data.result;
     const errors = (result.errors || []);
-    console.log(`共检查到 ${errors.length} 个错误`);
-    if (errors.length > 0)
+    if (errors.length > 0) {
+        result.errorStr = `检查到以下错误（共 ${errors.length} 个）：\n` + result.errorStr;
         return truncate(result.errorStr, 10000);
+    }
     return '';
 }
 
@@ -29349,9 +29333,11 @@ function composeToString(files) {
         // 判断是否是特殊文件类型（variables 或 extensions）
         const isVariablesFile = nameFromPath === 'variables';
         const isExtensionsFile = arr[0] === 'extensions';
-        const isSpecialFile = isVariablesFile || isExtensionsFile;
+        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)) {
             if (isVariablesFile) {
                 validateVariablesFile(file, errors);
@@ -29363,7 +29349,10 @@ function composeToString(files) {
                 validateNormalFile(file, nameFromPath, namespace, errors);
             }
         }
-        return `namespace ${namespace} {\n${file.content}\n}\n`;
+        else if (isThemeCss) {
+            content = `  $theme\`${content}\`;`;
+        }
+        return `namespace ${namespace} {\n${content}\n}\n`;
     })
         .join('\n');
     if (errors.length > 0) {
@@ -37886,13 +37875,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,
@@ -37906,7 +37998,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,
@@ -37920,9 +38011,9 @@ async function scanEntryFiles(projectRoot, patterns, logger) {
     }
 }
 /**
- * 从文件内容中提取 app.* 格式的依赖引用
+ * 从文件内容中提取 指定 格式的依赖引用
  * @param content 文件内容
- * @returns 依赖的 app.* 路径列表
+ * @returns 依赖的 指定 路径列表
  */
 function extractDeps(content) {
     const deps = new Set();
@@ -37932,28 +38023,34 @@ function extractDeps(content) {
         .replace(/\/\*[\s\S]*?\*\//g, '') // 移除多行注释 /* ... */
         .replace(/'(?:[^'\\]|\\.)*'/g, '') // 移除单引号字符串 'xxx'
         .replace(/"(?:[^"\\]|\\.)*"/g, ''); // 移除双引号字符串 "xxx"
-    const allMatches = processedContent.matchAll(/(app|extensions)\.\w+\.[\w.]+/g); // 起码要2个点，支持 app.* 和 extensions.*
-    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 (/\.variables\.(\w+)/.test(dep)) {
-            // 处理 variables 依赖：app.backend.variables.xxx -> app.backend.variables
-            dep = dep.replace(/\.variables\..+$/, '.variables');
-        }
-        else if (/^extensions\.\w+\.\w+/.test(dep)) {
-            // 处理 extensions 依赖：extensions.lcap_auth.xxx -> extensions.lcap_auth
-            dep = dep.replace(/^(extensions\.\w+)\..+$/, '$1');
-        }
-        else if (/app\.dataSources\.\w+\.entities\.\w+\.\w+$/.test(dep)) {
-            continue; // 应该是写法有问题，跳过让后面的 checker 做检查
+    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);
 }
@@ -38199,7 +38296,7 @@ async function compile(entry, options) {
         logger.success(`所有文件已输出到: ${outDir}`);
     }
     catch (error) {
-        logger.error(`编译失败：\n${error.message}`);
+        logger.error(`编译过程发生错误：\n${error.message}`);
         logger.exit(1);
     }
     return { config, outDir };
@@ -38666,7 +38763,7 @@ async function transform(transformType, entry, options) {
     await transformFn(entry, options);
 }
 
-var version = "0.1.19";
+var version = "0.2.1";
 var pkg = {
 	version: version};