@serveryyswys/opm 0.1.1 → 0.1.3

package/README.md

@@ -78,17 +78,67 @@ opm help
 
 ### 哪些文件会进包
 
+规则照 OPM，**只有三类**：
+
 | 类别 | 处理 |
 | --- | --- |
 | `manifest.json` | 原样 |
-| **JS**（入口 / 子包 / UI / 依赖） | 顺 `require` 链裁剪 + 裸名重写；**不可达的 JS 是死代码，不带** |
-| `resources/` `i18n/` `modules/` | **无条件整目录保留**，即使里面是 `.js` |
-| 其它非 JS 文件 | 原样带上（运行期数据，静态追不出来） |
-| 工程元数据（`package.json`/`tsconfig.json`/`.npmrc`…）与打包产物（`*.tgz`/`*.zip`） | 不带 |
-
-> 为什么要专门列这条：这三个规范目录**不在 require 链里**。只按 require 收集会把插件的
-> logo、多语言文件、WASM 模块**静默丢掉**且不报错。`i18n/*.js` 尤其容易被"不可达 JS 裁剪"
-> 误伤 —— 它是被 i18n 机制加载的**数据**，不是 require 出来的模块。
+| `main` / `subpackages[].entry` / UI 模块 | 读入、重写裸名、顺 require 链递归收集 |
+| `manifest.extra_files` 里列出的路径 | 文件直接收；目录**递归**收（跳过 `node_modules` 与点目录，深度上限 10） |
+
+**不在 require 闭包里、也没写进 `extra_files` 的文件一律不进包。** 这包括工程里的
+杂项（草稿、截图、临时配置）—— 归档内容因此是可解释的：闭包 + 入口 + 显式声明。
+
+> 为什么改：早先这里是"非 JS 一律原样带上"，会把杂项一起打进包，包体不可控
+> 也无法解释。对齐 OPM 的 `extra_files` 之后，"打了什么"完全由声明决定。
+
+### 构建清单 manifest.opmbuild.json（可选）
+
+项目根放一个 `manifest.opmbuild.json`，把**构建期**的决策与运行时 manifest 分开：
+
+```json
+{
+  "extra_files": ["resources", "i18n"],
+  "packinfo": { "enable": true }
+}
+```
+
+- `extra_files`：额外进包的路径，文件直接收，目录**递归**收（跳过 `node_modules` 与点目录）；
+- `packinfo`：是否生成 `PACKINFO`（见下）；
+- **优先级高于** `manifest.json` 里的同名字段；文件不存在就用 manifest 里的，都没有就不打额外文件；
+- 不是合法 JSON 会**明确报错**，不会静默忽略。
+
+> 为什么单独一个文件：`manifest.json` 是装上设备后给 Operit 读的**运行时**元数据，
+> 而"打哪些文件、要不要 PACKINFO"是**构建期**的事。混在一起会让运行时清单变脏。
+
+### PACKINFO（可选）
+
+在 manifest 里写：
+
+```json
+"packinfo": { "enable": true }
+```
+
+就会在归档根生成一个无扩展名的 `PACKINFO`（YAML），供市场审核核对：
+
+```yaml
+name: 打包信息
+description: 一句话说明
+id: top.serveryyswys.yourpkg
+version: 1.0.0
+author: "甲, 乙"
+license: Apache-2.0
+dependencies:
+  - "@serveryyswys/node.operit"
+  - ms
+```
+
+- 字段顺序固定 `name → description → id → version → author → license → dependencies`，
+  有才写、缺则跳过；
+- `dependencies` 从**归档里实际收进的** `node_modules/<pkg>/...` 反推，
+  所以因内建重写带进来的 `node.operit` 也会如实列出；
+- `enable` 不为 `true` 时不生成该文件；
+- 含 `@` / `,` / `:` 等字符的值会按 YAML 规则加双引号。
 
 ### 裸名重写的三条规则
 

package/dist/cli.js

@@ -34,7 +34,7 @@ function usage() {
         '用法：',
         '  opm init [项目目录] [--no-install] [--overwrite]',
         '      把工程准备到能 build：补 scripts.build 与依赖声明、生成 manifest.json 骨架、',
-        '      TS 工程补 tsconfig.json。默认跑一次 npm install（不指定 registry，走你自己的 npm 源）。',
+        '      TS 工程补 tsconfig.json；默认装依赖。',
         '',
         '  opm build [项目目录] [--out <名字>] [--dry-run] [--no-install]',
         '      计算可达性、重写裸名、拦截不支持的依赖，压成 .toolpkg',
@@ -75,6 +75,15 @@ function parseArgs(argv) {
     }
     return { positional, flags };
 }
+function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return bytes + ' B';
+    }
+    if (bytes < 1024 * 1024) {
+        return (bytes / 1024).toFixed(1) + ' KB';
+    }
+    return (bytes / 1024 / 1024).toFixed(1) + ' MB';
+}
 function main(argv) {
     const command = argv[0];
     const { positional, flags } = parseArgs(argv.slice(1));
@@ -102,8 +111,10 @@ function main(argv) {
         for (const item of result.unchanged) {
             console.log('  = ' + item + '（已存在，未改动）');
         }
-        for (const note of result.notes) {
-            console.log('  · ' + note);
+        if (flags.has('verbose')) {
+            for (const note of result.notes) {
+                console.log('  · ' + note);
+            }
         }
         if (!result.ok) {
             console.error('');
@@ -113,10 +124,11 @@ function main(argv) {
             }
             return 1;
         }
-        console.log('');
-        console.log('下一步：');
-        for (const step of result.nextSteps) {
-            console.log('  ' + step);
+        if (result.nextSteps.length > 0) {
+            console.log('');
+            for (const step of result.nextSteps) {
+                console.log('  ' + step);
+            }
         }
         return 0;
     }
@@ -128,60 +140,51 @@ function main(argv) {
             dryRun: flags.has('dry-run'),
             install: !flags.has('no-install')
         });
-        for (const note of result.notes) {
-            console.log('  · ' + note);
+        if (!result.ok) {
+            for (const error of result.errors) {
+                console.error('✗ ' + error);
+            }
+            return 1;
         }
-        if (result.diagnostics.length > 0) {
+        if (flags.has('verbose')) {
+            for (const note of result.notes) {
+                console.log('· ' + note);
+            }
             const byKind = new Map();
             for (const item of result.diagnostics) {
                 byKind.set(item.kind, (byKind.get(item.kind) ?? 0) + 1);
             }
-            const summary = Array.from(byKind.entries()).map(([kind, count]) => kind + ' ' + count).join(' / ');
-            console.log('  重写 ' + result.diagnostics.length + ' 处（' + summary + '）');
-        }
-        if (!result.ok) {
-            console.error('');
-            console.error('构建失败（' + result.errors.length + ' 个问题）：');
-            for (const error of result.errors) {
-                console.error('  ✗ ' + error);
-            }
-            return 1;
+            const summary = Array.from(byKind.entries()).map(([kind, count]) => kind + ' ' + count).join(', ');
+            console.log('· 重写 ' + result.diagnostics.length + ' 处（' + summary + '）');
         }
-        console.log('');
-        console.log('✓ 已打包 ' + result.fileCount + ' 个文件');
-        console.log('  ' + result.toolpkgPath);
+        console.log('✓ ' + result.toolpkgPath + '  (' + result.fileCount + ' 个文件, ' + formatBytes(result.totalBytes) + ')');
         return 0;
     }
     if (command === 'verify') {
         const projectDir = (0, node_path_1.resolve)(positional[0] === undefined ? process.cwd() : positional[0]);
         const report = (0, verify_1.verifyProject)({ projectDir, install: !flags.has('no-install') });
-        console.log('检查项：');
-        for (const check of report.checks) {
-            console.log('  ' + (check.ok ? '✓' : '✗') + ' ' + check.name + ' —— ' + check.detail);
-        }
-        const stats = report.stats;
-        console.log('');
-        console.log('统计：');
-        console.log('  归档文件   ' + stats.archiveFiles + ' 个（其中资产 ' + stats.assets + ' 个），共 ' + stats.totalBytes + ' 字节');
-        console.log('  重写      内建 ' + stats.builtin + ' / npm 包 ' + stats.package + ' / 相对 ' + stats.relative + ' / 保持原样 ' + stats.untouched);
-        console.log('  引入的包  ' + (stats.packages.length === 0 ? '（无）' : stats.packages.join(', ')));
-        console.log('  node.operit ' + stats.nodeOperitVersion);
-        for (const note of report.notes) {
-            console.log('  · ' + note);
+        if (flags.has('verbose')) {
+            for (const check of report.checks) {
+                console.log((check.ok ? '✓ ' : '✗ ') + check.name + ' —— ' + check.detail);
+            }
+            const stats = report.stats;
+            console.log('· 归档 ' + stats.archiveFiles + ' 个文件, ' + formatBytes(stats.totalBytes)
+                + '；额外文件 ' + stats.assets + '；依赖 ' + (stats.packages.length === 0 ? '无' : stats.packages.join(', '))
+                + '；node.operit ' + stats.nodeOperitVersion);
+            for (const note of report.notes) {
+                console.log('· ' + note);
+            }
         }
         for (const warning of report.warnings) {
-            console.log('  ! ' + warning);
+            console.log('! ' + warning);
         }
         if (!report.ok) {
-            console.error('');
-            console.error('校验未通过（' + report.errors.length + ' 个问题）：');
             for (const error of report.errors) {
-                console.error('  ✗ ' + error);
+                console.error('✗ ' + error);
             }
             return 1;
         }
-        console.log('');
-        console.log('✓ 校验通过（未写任何文件）');
+        console.log('✓ 校验通过');
         return 0;
     }
     if (command === 'version') {

package/dist/lib/build.js

@@ -12,6 +12,7 @@ exports.buildProject = buildProject;
  *   5. 入口注入 process / Buffer 全局（沙盒没有这两个全局）；
  *   6. 压成 zip，产物放项目根的上一级，名为 <项目目录名>.toolpkg。
  */
+const packinfo_1 = require("./packinfo");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const zip_1 = require("./zip");
@@ -76,7 +77,7 @@ function buildProject(options) {
                 '    执行 npm install 补齐后重试（本次带了 --no-install，所以没有自动装）。');
             return { ok: false, toolpkgPath: '', fileCount: 0, files: [], totalBytes: 0, assets: [], diagnostics, errors, notes };
         }
-        notes.push('检测到缺少依赖：' + audit.missing.join(', ') + '，正在执行 npm install');
+        notes.push('缺少依赖，正在安装：' + audit.missing.join(', '));
         const installed = (0, dependencies_1.installDependencies)(projectDir);
         if (!installed.ok) {
             errors.push('npm install 失败：\n' + installed.output.trim());
@@ -119,6 +120,7 @@ function buildProject(options) {
     }
     const locate = (0, typescript_1.createLocator)(projectDir, plan.outDir);
     const env = { locate, contract, nodeOperitArchiveDir: contract_1.NODE_OPERIT_DIR };
+    const buildConfig = readBuildConfig(projectDir, errors);
     const seeds = collectSeeds(manifest, errors);
     // 入口要注入 process / Buffer 全局（沙盒没有这两个全局）。
     // 关键是：**注入必须在可达性遍历之前登记**，把被注入引用的这两个文件
@@ -174,18 +176,16 @@ function buildProject(options) {
         rewritten.set(entryPath, prelude + rewritten.get(entryPath));
         notes.push('已向入口 ' + entryPath + ' 注入 process / Buffer 全局');
     }
-    // 非 JS 资产原样带上（resources / i18n / modules 等）
-    const reachableDiskPaths = new Set();
-    for (const archivePath of rewritten.keys()) {
-        const disk = locate(archivePath);
-        if (disk !== null) {
-            reachableDiskPaths.add(disk);
-        }
-    }
-    const collected = collectAssets(projectDir, plan.outDir, reachableDiskPaths);
+    // 额外文件：只收 manifest.extra_files 里显式声明的（照 OPM 的语义）
+    const archivePathSet = new Set(rewritten.keys());
+    archivePathSet.add('manifest.json');
+    const configExtra = Array.isArray(buildConfig.extra_files) ? buildConfig.extra_files : null;
+    const manifestExtra = Array.isArray(manifest.extra_files) ? manifest.extra_files : [];
+    const extraFiles = configExtra !== null ? configExtra : manifestExtra;
+    const collected = collectExtraFiles(projectDir, extraFiles, archivePathSet);
     errors.push(...collected.errors);
     if (collected.assets.length > 0) {
-        notes.push('原样带上 ' + collected.assets.length + ' 个非代码资产（resources / i18n / modules 等）');
+        notes.push('按 extra_files 带上 ' + collected.assets.length + ' 个额外文件');
     }
     const outName = options.outName === undefined ? baseName(projectDir) : options.outName;
     const toolpkgPath = (0, node_path_1.join)((0, node_path_1.dirname)(projectDir), outName + '.toolpkg');
@@ -210,6 +210,17 @@ function buildProject(options) {
     for (const entry of archiveEntries) {
         totalBytes += entry.content.length;
     }
+    // PACKINFO：仅在 manifest.packinfo.enable === true 时生成
+    const configPackinfo = buildConfig.packinfo;
+    const packinfoOptions = (configPackinfo !== undefined && configPackinfo !== null
+        ? configPackinfo
+        : manifest.packinfo);
+    const packinfoText = (0, packinfo_1.renderPackInfo)(manifest, packinfoOptions, archiveEntries.map((entry) => entry.path));
+    if (packinfoText !== null) {
+        entries.push({ path: 'PACKINFO', content: Buffer.from(packinfoText, 'utf8') });
+        archiveEntries.push({ path: 'PACKINFO', content: Buffer.from(packinfoText, 'utf8') });
+        notes.push('已生成 PACKINFO（' + packinfoText.split('\n').length + ' 行）');
+    }
     const archive = (0, zip_1.createZip)(entries);
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(toolpkgPath), { recursive: true });
     (0, node_fs_1.writeFileSync)(toolpkgPath, archive);
@@ -226,78 +237,82 @@ function buildProject(options) {
     };
 }
 /**
- * 非 JS 资产的收集。
+ * 额外文件收集 —— 照 OPM 的 extra_files 语义。
  *
- * 规则：**JS 按可达性裁剪，非 JS 一律原样带上。**
+ * OPM（src/build/extrafiles.ts）只收 manifest 显式列出的路径：
+ *   - 是文件 → 收；
+ *   - 是目录 → **递归**收集其下文件（跳过 node_modules 与点目录，深度上限 10）；
+ *   - 不在列表里的一律不进归档。
  *
- * 为什么：resources / i18n / modules（WASM）这类文件是运行期数据，
- * 静态追 require 是追不到的 —— 早先只按 require 链收集，会把插件的 logo、
- * 多语言文件、WASM 模块**静默丢掉**，而且不报错。官方打包脚本本来就是整包 zip，
- * 使用者按"东西都在包里"预期；这里只裁掉死代码，不再动数据文件。
- */
-const ASSET_SKIP_DIRS = new Set(['node_modules', '.git']);
-const ASSET_SKIP_FILES = new Set([
-    // manifest 由构建流程显式加入，不能再被资产收集加一遍（否则 zip 里出现重复条目）
-    'manifest.json', 'manifest.hjson',
-    'package.json', 'package-lock.json', 'npm-shrinkwrap.json',
-    'tsconfig.json', '.npmrc', '.gitignore', '.gitattributes'
-]);
-const ARCHIVE_LIKE = /\.(tgz|zip|tar|gz)$/i;
-const SCRIPT_LIKE = /\.(js|cjs|mjs|ts|jsx|tsx|map)$/i;
-/**
- * 这三个目录**无条件整目录保留**，即使里面的文件是 .js。
- * 因为 i18n/*.js 是被 i18n 机制加载的**数据**，不是 require 出来的模块 ——
- * 按"JS 一律按可达性裁剪"会把多语言文件一起丢掉，正是这次要修的坑。
+ * 之前这里写的是"非 JS 一律原样带上"，那是错的：它会把工程里的杂项
+ * （草稿、截图、临时配置）一起打进包，包体不可控也不可解释。
+ * 现在归档内容 = require 闭包 + manifest 声明的入口 + 显式 extra_files，没有别的。
  */
-const ALWAYS_INCLUDE_DIRS = new Set(['resources', 'i18n', 'modules']);
-function collectAssets(projectDir, outDir, reachableDiskPaths) {
+const EXTRA_SKIP_DIRS = new Set(['node_modules']);
+const EXTRA_MAX_DEPTH = 10;
+function collectExtraFiles(projectDir, extraFiles, archivePaths) {
     const assets = [];
     const errors = [];
-    const outDirPrefix = outDir === null ? null : outDir.replace(/[\\/]+$/, '') + node_path_1.sep;
-    const walk = (dir, prefix, insideAlways) => {
+    const seen = new Set();
+    const addFile = (archivePath) => {
+        const normalized = toPosix(archivePath).replace(/^\.\//, '');
+        if (normalized === '' || seen.has(normalized) || archivePaths.has(normalized)) {
+            return; // 已在 require 闭包里，不重复
+        }
+        const disk = (0, node_path_1.resolve)(projectDir, normalized);
+        if (!(0, node_fs_1.existsSync)(disk) || !(0, node_fs_1.statSync)(disk).isFile()) {
+            return;
+        }
+        seen.add(normalized);
+        assets.push({ path: normalized, disk });
+    };
+    const walkDir = (relDir, depth) => {
+        if (depth <= 0) {
+            return;
+        }
+        const absDir = (0, node_path_1.resolve)(projectDir, relDir);
         let entries;
         try {
-            entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+            entries = (0, node_fs_1.readdirSync)(absDir, { withFileTypes: true });
         }
         catch (error) {
-            errors.push('读取目录失败：' + dir + ' —— ' + String(error));
+            errors.push('读取目录失败：' + relDir + ' —— ' + String(error));
             return;
         }
         for (const entry of entries) {
-            const archivePath = prefix === '' ? entry.name : prefix + '/' + entry.name;
-            const disk = (0, node_path_1.join)(dir, entry.name);
-            const nextInsideAlways = insideAlways || (prefix === '' && ALWAYS_INCLUDE_DIRS.has(entry.name));
+            if (entry.name.startsWith('.')) {
+                continue; // 点目录/点文件不进包
+            }
+            const childRel = relDir === '' ? entry.name : relDir + '/' + entry.name;
             if (entry.isDirectory()) {
-                if (ASSET_SKIP_DIRS.has(entry.name)) {
+                if (EXTRA_SKIP_DIRS.has(entry.name)) {
                     continue;
                 }
-                if (outDirPrefix !== null && (disk + node_path_1.sep).startsWith(outDirPrefix)) {
-                    continue; // 编译产物目录：它的 JS 由可达性接管
-                }
-                walk(disk, archivePath, nextInsideAlways);
-                continue;
-            }
-            if (prefix === '' && ASSET_SKIP_FILES.has(entry.name)) {
-                continue;
-            }
-            if (!nextInsideAlways && ARCHIVE_LIKE.test(entry.name)) {
-                continue; // 打包产物不该再进包 —— 但 resources/ 里的 zip 是合法资源，规范明确支持
-            }
-            if (reachableDiskPaths.has(disk)) {
-                continue; // 已经是可达 JS，不重复
-            }
-            // 规范目录之外：脚本类文件交给可达性裁剪（不可达的 JS 是死代码），
-            // 其它一律当数据带上。
-            if (!nextInsideAlways && SCRIPT_LIKE.test(entry.name)) {
+                walkDir(childRel, depth - 1);
                 continue;
             }
-            assets.push({ path: archivePath, disk });
+            addFile(childRel);
         }
     };
-    walk(projectDir, '', false);
+    for (const raw of extraFiles) {
+        const rel = toPosix(String(raw)).replace(/^\.\//, '');
+        if (rel === '') {
+            continue;
+        }
+        const abs = (0, node_path_1.resolve)(projectDir, rel);
+        if (!(0, node_fs_1.existsSync)(abs)) {
+            errors.push('extra_files 里声明的路径不存在：' + rel);
+            continue;
+        }
+        if ((0, node_fs_1.statSync)(abs).isDirectory()) {
+            walkDir(rel, EXTRA_MAX_DEPTH);
+            continue;
+        }
+        addFile(rel);
+    }
     return { assets, errors };
 }
-/** 归档正文的总字节（未压缩）：重写后的 JS + 原样资产。dry-run 也要能报出来。 */
+/** 归档正文的总字节（未压缩）：重写后的 JS + 额外文件。dry-run 也要能报出来。 */
 function measureBytes(files, assets) {
     let total = 0;
     for (const code of files.values()) {
@@ -313,6 +328,41 @@ function measureBytes(files, assets) {
     }
     return total;
 }
+/**
+ * 构建期清单（可选）：项目根的 manifest.opmbuild.json。
+ *
+ * 为什么不塞进 manifest.json：manifest.json 是**运行时**元数据（装到设备上给 Operit 读的），
+ * 而"打哪些额外文件、要不要生成 PACKINFO"是**构建期**决策，混在一起会让运行时清单变脏。
+ * 单独一个清单文件，职责清楚，也可以不提交（看团队习惯）。
+ *
+ * 形状：
+ *   {
+ *     "extra_files": ["resources", "i18n/zh-CN.js"],
+ *     "packinfo": { "enable": true }
+ *   }
+ *
+ * 兼容：manifest.json 里同名字段仍然生效（先看构建清单，再看 manifest）。
+ */
+const OPM_BUILD_CONFIG = 'manifest.opmbuild.json';
+function readBuildConfig(projectDir, errors) {
+    const configPath = (0, node_path_1.join)(projectDir, OPM_BUILD_CONFIG);
+    if (!(0, node_fs_1.existsSync)(configPath)) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(configPath, 'utf8'));
+    }
+    catch (error) {
+        errors.push(OPM_BUILD_CONFIG + ' 不是合法 JSON：' + String(error));
+        return {};
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        errors.push(OPM_BUILD_CONFIG + ' 的顶层必须是对象');
+        return {};
+    }
+    return parsed;
+}
 function baseName(value) {
     const normalized = value.replace(/[\\/]+$/, '');
     const index = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\'));

package/dist/lib/init.js

@@ -177,7 +177,7 @@ function initProject(options) {
             errors.push('npm install 失败：\n' + installOutput.trim());
         }
         else {
-            notes.push('已执行 npm install（源按你自己的 npm 配置，未指定 registry）');
+            notes.push('已执行 npm install');
         }
     }
     else {

package/dist/lib/js-requires.d.ts

@@ -8,8 +8,15 @@
  * 以及 "// require('x')" 这种情况。
  */
 export interface RequireSite {
-    /** require 的实参（已去引号、已解转义） */
-    spec: string;
+    /** require 的实参（已去引号、已解转义）；**动态形式为 null** */
+    spec: string | null;
+    /**
+     * 无法静态分析（变量 / 模板串 / 字符串拼接 / 三元…）。
+     *
+     * 这类 require 打包器改不了，而 Operit 运行时对裸名**静默返回 {}** ——
+     * 于是依赖在业务里神秘失效。所以必须显式报错，不能放过。
+     */
+    dynamic: boolean;
     /** spec 在源码里的起止下标（不含引号），替换时用 */
     start: number;
     end: number;

package/dist/lib/js-requires.js

@@ -97,12 +97,29 @@ function findRequires(source) {
                             cursor += 1;
                         }
                         if (cursor < length) {
-                            sites.push({ spec: value, start: start, end: cursor });
+                            // 字面量后面若还跟着运算（'a' + x / 'a' ? ...），实参其实是表达式。
+                            // 以前这里会把它当成 'a' 去重写 —— 截断比忽略更糟，必须区分。
+                            let after = cursor + 1;
+                            while (after < length && /\s/.test(source[after])) {
+                                after += 1;
+                            }
+                            const trailing = source[after];
+                            const isExpression = trailing === '+' || trailing === '?' || trailing === '|' || trailing === '&';
+                            sites.push({
+                                spec: isExpression ? null : value,
+                                dynamic: isExpression,
+                                start: start,
+                                end: cursor
+                            });
                             index = cursor + 1;
                             previousMeaningful = quote;
                             continue;
                         }
                     }
+                    else {
+                        // 实参不是字符串字面量：变量 / 模板串 / 三元 / 函数调用…全部无法静态改写
+                        sites.push({ spec: null, dynamic: true, start: cursor, end: cursor });
+                    }
                 }
             }
         }

package/dist/lib/packinfo.d.ts

@@ -0,0 +1,29 @@
+/**
+ * PACKINFO：打包信息核对文件（归档根，文件名无扩展名，内容 YAML）。
+ *
+ * 语义对齐 OPM 的 src/build/packinfo.ts：
+ *   - 仅当 manifest.packinfo.enable === true 时生成；否则不写这个文件；
+ *   - 字段顺序固定 name → description → id → version → author → license → dependencies；
+ *   - 每个字段「有才写、缺则跳过」；id / version 恒有（manifest 是构建前提）；
+ *   - dependencies 从**归档内实际收进的路径**反推（node_modules/<pkg>/... → 包名），
+ *     作用域粒度为 @scope/pkg，去重并保持首次出现顺序；
+ *   - 不写 extra_files。
+ */
+export interface PackInfoOptions {
+    /** 开关：仅 true 时生成 */
+    enable?: unknown;
+    name?: unknown;
+    description?: unknown;
+    version?: unknown;
+    author?: unknown;
+    license?: unknown;
+}
+/**
+ * 从归档路径集合推导依赖列表。
+ *
+ * 依据"实际进包的文件"而不是"解析到的裸名"：这样 node.operit 这类因内建重写
+ * 而带进来的运行时也会被如实列为依赖 —— 它就是依赖。
+ */
+export declare function collectDependenciesFromArchive(archivePaths: Iterable<string>): string[];
+/** 生成 PACKINFO 文本；返回 null 表示不生成。 */
+export declare function renderPackInfo(manifest: Record<string, unknown>, options: PackInfoOptions | null | undefined, archivePaths: Iterable<string>): string | null;

package/dist/lib/packinfo.js

@@ -0,0 +1,123 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectDependenciesFromArchive = collectDependenciesFromArchive;
+exports.renderPackInfo = renderPackInfo;
+/** 取本地化文本：优先 .zh，其次 .en，再次任意非空字符串。 */
+function localized(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value !== null && typeof value === 'object') {
+        const obj = value;
+        if (typeof obj.zh === 'string' && obj.zh !== '') {
+            return obj.zh;
+        }
+        if (typeof obj.en === 'string' && obj.en !== '') {
+            return obj.en;
+        }
+        for (const key of Object.keys(obj)) {
+            const candidate = obj[key];
+            if (typeof candidate === 'string' && candidate !== '') {
+                return candidate;
+            }
+        }
+    }
+    return '';
+}
+/** YAML 标量：含特殊字符时才加双引号。 */
+function yamlScalar(value) {
+    const text = String(value);
+    if (/^\s|\s$/.test(text) || /[:#"'\[\]{}&*!|>%@`,]/.test(text) || /\n/.test(text)) {
+        return '"' + text.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"';
+    }
+    return text;
+}
+/**
+ * 从归档路径集合推导依赖列表。
+ *
+ * 依据"实际进包的文件"而不是"解析到的裸名"：这样 node.operit 这类因内建重写
+ * 而带进来的运行时也会被如实列为依赖 —— 它就是依赖。
+ */
+function collectDependenciesFromArchive(archivePaths) {
+    const out = [];
+    const seen = new Set();
+    const prefix = 'node_modules/';
+    for (const raw of archivePaths) {
+        const path = String(raw === undefined ? '' : raw).replace(/\\/g, '/');
+        if (path.indexOf(prefix) !== 0) {
+            continue;
+        }
+        const segments = path.slice(prefix.length).split('/');
+        let name = '';
+        if (segments[0].charAt(0) === '@') {
+            if (segments.length < 2 || segments[1] === '') {
+                continue;
+            }
+            name = segments[0] + '/' + segments[1];
+        }
+        else {
+            if (segments[0] === '') {
+                continue;
+            }
+            name = segments[0];
+        }
+        if (seen.has(name)) {
+            continue;
+        }
+        seen.add(name);
+        out.push(name);
+    }
+    return out;
+}
+/** 生成 PACKINFO 文本；返回 null 表示不生成。 */
+function renderPackInfo(manifest, options, archivePaths) {
+    if (options === null || options === undefined || options.enable !== true) {
+        return null;
+    }
+    const lines = [];
+    const name = String(options.name === undefined ? '' : options.name) ||
+        localized(manifest.display_name) || localized(manifest.displayName);
+    if (name !== '') {
+        lines.push('name: ' + yamlScalar(name));
+    }
+    const description = String(options.description === undefined ? '' : options.description) || localized(manifest.description);
+    if (description !== '') {
+        lines.push('description: ' + yamlScalar(description));
+    }
+    const id = String(manifest.toolpkg_id === undefined ? (manifest.id === undefined ? '' : manifest.id) : manifest.toolpkg_id);
+    if (id !== '') {
+        lines.push('id: ' + yamlScalar(id));
+    }
+    const version = String(options.version === undefined ? '' : options.version) || String(manifest.version === undefined ? '' : manifest.version);
+    if (version !== '') {
+        lines.push('version: ' + yamlScalar(version));
+    }
+    let author = String(options.author === undefined ? '' : options.author);
+    if (author === '') {
+        const raw = manifest.author;
+        if (Array.isArray(raw)) {
+            author = raw.map((item) => String(item)).filter((item) => item !== '').join(', ');
+        }
+        else if (typeof raw === 'string') {
+            author = raw;
+        }
+    }
+    if (author !== '') {
+        lines.push('author: ' + yamlScalar(author));
+    }
+    const license = String(options.license === undefined ? '' : options.license) || String(manifest.license === undefined ? '' : manifest.license);
+    if (license !== '') {
+        lines.push('license: ' + yamlScalar(license));
+    }
+    const dependencies = collectDependenciesFromArchive(archivePaths);
+    if (dependencies.length > 0) {
+        lines.push('dependencies:');
+        for (const dependency of dependencies) {
+            lines.push('  - ' + yamlScalar(dependency));
+        }
+    }
+    if (lines.length === 0) {
+        return null;
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/lib/rewrite.js

@@ -150,6 +150,12 @@ function rewriteModule(env, archivePath, source) {
     let output = source;
     for (let index = sites.length - 1; index >= 0; index -= 1) {
         const site = sites[index];
+        if (site.dynamic) {
+            // 改不了就必须说，不能默认放过：运行时对裸名静默返回 {}，
+            // 症状会是"某个依赖神秘失效"，比构建立刻失败难查得多。
+            errors.push(archivePath + ':' + site.start + ' 是无法静态分析的 require —— 运行时必然返回 {}。改用字面量：require(\'fs\')');
+            continue;
+        }
         const spec = site.spec;
         if (contract_1.RUNTIME_BUILTINS.includes(spec)) {
             diagnostics.push({ file: archivePath, spec, kind: 'untouched', target: spec });

package/dist/lib/verify.js

@@ -107,11 +107,11 @@ function verifyProject(options) {
             : built.errors.length + ' 个问题（见 errors）'
     });
     checks.push({
-        name: '资产保留',
+        name: '额外文件（extra_files）',
         ok: true,
         detail: built.assets.length === 0
-            ? '工程没有非代码资产'
-            : '原样带上 ' + built.assets.length + ' 个资产'
+            ? 'manifest 没有声明 extra_files'
+            : '按 extra_files 带上 ' + built.assets.length + ' 个文件'
     });
     const counted = { builtin: 0, package: 0, relative: 0, untouched: 0 };
     const packageNames = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serveryyswys/opm",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "把 Operit 插件工程打成 .toolpkg 的构建器（传统 Node 开发环境，不依赖 Operit 运行时）",
   "license": "GPL-3.0-or-later",
   "author": "serveryyswys",