@serveryyswys/opm 0.0.0-stage → 0.1.0

package/dist/lib/init.js

@@ -0,0 +1,188 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPM_PACKAGE = void 0;
+exports.initProject = initProject;
+/**
+ * opm init：把工程准备到"能 build"。
+ *
+ * 只管三件事（都是最容易写错的地方）：
+ *   1. package.json 里补 scripts.build = "opm build"，以及两个 devDependency；
+ *   2. 没有 manifest.json 就生成一个骨架（toolpkg 的身份靠它）；
+ *   3. 工程里有 .ts 就补一个 tsconfig.json，且 outDir 与 manifest 的路径对得上。
+ *
+ * **不写死 registry**：依赖从哪来由使用者自己的 npm 配置决定。
+ * 默认会跑一次 npm install（可用 --no-install 关掉），因为没装 node.operit 就 build 不了。
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const contract_1 = require("./contract");
+const dependencies_1 = require("./dependencies");
+exports.OPM_PACKAGE = '@serveryyswys/opm';
+function readJson(path) {
+    if (!(0, node_fs_1.existsSync)(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(path, value) {
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(value, null, 2) + '\n', 'utf8');
+}
+/** 目录里有没有 .ts（跳过 node_modules）。 */
+function hasTypeScript(projectDir) {
+    const stack = [projectDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                stack.push((0, node_path_1.join)(current, entry.name));
+            }
+            else if (entry.name.endsWith('.ts')) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function initProject(options) {
+    const projectDir = (0, node_path_1.resolve)(options.projectDir);
+    const install = options.install !== false;
+    const overwrite = options.overwrite === true;
+    const created = [];
+    const updated = [];
+    const unchanged = [];
+    const notes = [];
+    const errors = [];
+    const nextSteps = [];
+    if (!(0, node_fs_1.existsSync)(projectDir)) {
+        (0, node_fs_1.mkdirSync)(projectDir, { recursive: true });
+        created.push(projectDir + '/');
+    }
+    const projectName = (0, node_path_1.basename)(projectDir);
+    // ---- package.json
+    const packagePath = (0, node_path_1.join)(projectDir, 'package.json');
+    const existingPackage = readJson(packagePath);
+    const manifest = existingPackage === null ? {} : existingPackage;
+    let packageChanged = false;
+    const scripts = manifest.scripts === null || typeof manifest.scripts !== 'object'
+        ? {}
+        : manifest.scripts;
+    if (overwrite || typeof scripts.build !== 'string') {
+        scripts.build = 'opm build';
+        packageChanged = true;
+    }
+    manifest.scripts = scripts;
+    const devDependencies = manifest.devDependencies === null || typeof manifest.devDependencies !== 'object'
+        ? {}
+        : manifest.devDependencies;
+    for (const name of [exports.OPM_PACKAGE, contract_1.NODE_OPERIT_PACKAGE]) {
+        if (overwrite || devDependencies[name] === undefined) {
+            // 用 latest：版本由源上的最新决定，不在生成物里钉死一个会过期的号
+            devDependencies[name] = 'latest';
+            packageChanged = true;
+        }
+    }
+    manifest.devDependencies = devDependencies;
+    if (manifest.name === undefined) {
+        manifest.name = projectName;
+        packageChanged = true;
+    }
+    if (manifest.private === undefined) {
+        manifest.private = true;
+        packageChanged = true;
+    }
+    if (existingPackage === null) {
+        writeJson(packagePath, manifest);
+        created.push('package.json');
+    }
+    else if (packageChanged) {
+        writeJson(packagePath, manifest);
+        updated.push('package.json');
+    }
+    else {
+        unchanged.push('package.json');
+    }
+    // ---- manifest.json（toolpkg 身份）
+    const toolpkgPath = (0, node_path_1.join)(projectDir, 'manifest.json');
+    if (!(0, node_fs_1.existsSync)(toolpkgPath)) {
+        // 目录名可能以 . 或 _ 开头（.e2e-opm / _probe），直接拼会得到 "com.example..e2e-opm"
+        const safeName = projectName
+            .replace(/[^A-Za-z0-9_.-]/g, '-')
+            .replace(/^[^A-Za-z0-9]+/, '')
+            .replace(/[^A-Za-z0-9]+$/, '');
+        const toolpkgId = 'com.example.' + (safeName.length > 0 ? safeName : 'plugin');
+        const hasTs = hasTypeScript(projectDir);
+        writeJson(toolpkgPath, {
+            schema_version: 1,
+            toolpkg_id: toolpkgId,
+            version: '0.1.0',
+            api_version: '1.0.1',
+            author: [''],
+            main: hasTs ? 'dist/main.js' : 'main.js',
+            display_name: { zh: projectName, en: projectName },
+            description: { zh: '（待填写）', en: '(to be filled)' },
+            subpackages: []
+        });
+        created.push('manifest.json');
+        notes.push('manifest.json 里的 toolpkg_id 现在是 ' + toolpkgId + '，发布前请改成你自己的');
+    }
+    else {
+        unchanged.push('manifest.json');
+    }
+    // ---- tsconfig.json（只在工程确实有 .ts 时生成，免得把纯 JS 工程推进 TS 模式）
+    const tsconfigPath = (0, node_path_1.join)(projectDir, 'tsconfig.json');
+    const wantsTypeScript = (0, node_fs_1.existsSync)(tsconfigPath) || hasTypeScript(projectDir);
+    if (wantsTypeScript && !(0, node_fs_1.existsSync)(tsconfigPath)) {
+        writeJson(tsconfigPath, {
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'node16',
+                moduleResolution: 'node16',
+                lib: ['ES2020'],
+                rootDir: 'src',
+                outDir: 'dist',
+                strict: true,
+                declaration: false,
+                skipLibCheck: true,
+                types: []
+            },
+            include: ['src/**/*.ts']
+        });
+        created.push('tsconfig.json');
+        notes.push('tsconfig 的 outDir 是 dist、rootDir 是 src，所以 manifest.main 要写 dist/main.js');
+    }
+    else if ((0, node_fs_1.existsSync)(tsconfigPath)) {
+        unchanged.push('tsconfig.json');
+    }
+    // ---- 依赖
+    let installOutput = '';
+    if (install) {
+        const installed = (0, dependencies_1.installDependencies)(projectDir);
+        installOutput = installed.output;
+        if (!installed.ok) {
+            errors.push('npm install 失败：\n' + installOutput.trim());
+        }
+        else {
+            notes.push('已执行 npm install（源按你自己的 npm 配置，未指定 registry）');
+        }
+    }
+    else {
+        nextSteps.push('npm install');
+    }
+    nextSteps.push('npm run build');
+    return { ok: errors.length === 0, created, updated, unchanged, notes, errors, nextSteps };
+}

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

@@ -0,0 +1,17 @@
+/**
+ * 从 JS 源码里找出所有 require(...) 调用点。
+ *
+ * 必须跳过注释与字符串 —— 否则文档注释里写一个 require 例子就会被当成真依赖，
+ * 把一个不存在的模块拖进归档、或者让构建直接失败。
+ *
+ * 状态机而不是正则：正则没法同时正确处理 \` 模板串、字符串里的引号逃逸、
+ * 以及 "// require('x')" 这种情况。
+ */
+export interface RequireSite {
+    /** require 的实参（已去引号、已解转义） */
+    spec: string;
+    /** spec 在源码里的起止下标（不含引号），替换时用 */
+    start: number;
+    end: number;
+}
+export declare function findRequires(source: string): RequireSite[];

package/dist/lib/js-requires.js

@@ -0,0 +1,115 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRequires = findRequires;
+const QUOTES = new Set(["'", '"', '\`']);
+function findRequires(source) {
+    const sites = [];
+    let index = 0;
+    const length = source.length;
+    // 上一个有意义字符，用于区分正则字面量与除号
+    let previousMeaningful = '';
+    while (index < length) {
+        const char = source[index];
+        // 行注释
+        if (char === '/' && source[index + 1] === '/') {
+            const newline = source.indexOf('\n', index);
+            index = newline < 0 ? length : newline + 1;
+            continue;
+        }
+        // 块注释
+        if (char === '/' && source[index + 1] === '*') {
+            const close = source.indexOf('*/', index + 2);
+            index = close < 0 ? length : close + 2;
+            continue;
+        }
+        // 字符串 / 模板串
+        if (QUOTES.has(char)) {
+            const quote = char;
+            index += 1;
+            while (index < length) {
+                if (source[index] === '\\') {
+                    index += 2;
+                    continue;
+                }
+                if (source[index] === quote) {
+                    index += 1;
+                    break;
+                }
+                index += 1;
+            }
+            previousMeaningful = quote;
+            continue;
+        }
+        // 正则字面量：出现在"期待操作数"的位置时才是正则，否则是除号
+        if (char === '/' && (previousMeaningful === '' || '(,=:[!&|?{};+-*%~^<>'.includes(previousMeaningful))) {
+            index += 1;
+            let inClass = false;
+            while (index < length) {
+                const c = source[index];
+                if (c === '\\') {
+                    index += 2;
+                    continue;
+                }
+                if (c === '[') {
+                    inClass = true;
+                }
+                else if (c === ']') {
+                    inClass = false;
+                }
+                else if (c === '/' && !inClass) {
+                    index += 1;
+                    break;
+                }
+                else if (c === '\n') {
+                    break;
+                }
+                index += 1;
+            }
+            previousMeaningful = '/';
+            continue;
+        }
+        if (char === 'r' && source.startsWith('require', index)) {
+            const before = index === 0 ? '' : source[index - 1];
+            const isIdentifierChar = /[A-Za-z0-9_$]/.test(before);
+            if (!isIdentifierChar) {
+                let cursor = index + 'require'.length;
+                while (cursor < length && /\s/.test(source[cursor])) {
+                    cursor += 1;
+                }
+                if (source[cursor] === '(') {
+                    cursor += 1;
+                    while (cursor < length && /\s/.test(source[cursor])) {
+                        cursor += 1;
+                    }
+                    const quote = source[cursor];
+                    if (quote === "'" || quote === '"') {
+                        cursor += 1;
+                        const start = cursor;
+                        let value = '';
+                        while (cursor < length && source[cursor] !== quote) {
+                            if (source[cursor] === '\\') {
+                                const escaped = source[cursor + 1];
+                                value += escaped === 'n' ? '\n' : escaped === 't' ? '\t' : escaped;
+                                cursor += 2;
+                                continue;
+                            }
+                            value += source[cursor];
+                            cursor += 1;
+                        }
+                        if (cursor < length) {
+                            sites.push({ spec: value, start: start, end: cursor });
+                            index = cursor + 1;
+                            previousMeaningful = quote;
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        if (!/\s/.test(char)) {
+            previousMeaningful = char;
+        }
+        index += 1;
+    }
+    return sites;
+}

package/dist/lib/rewrite.d.ts

@@ -0,0 +1,24 @@
+import { Contract } from './contract';
+export interface Diagnostic {
+    file: string;
+    spec: string;
+    kind: 'builtin' | 'package' | 'relative' | 'untouched';
+    target: string;
+}
+export interface RewriteOutcome {
+    code: string;
+    diagnostics: Diagnostic[];
+    errors: string[];
+    /** 本次重写引入、需要继续处理的新文件（归档路径） */
+    discovered: string[];
+}
+export interface RewriteEnv {
+    /** 归档路径 -> 磁盘绝对路径；不存在返回 null */
+    locate(archivePath: string): string | null;
+    contract: Contract;
+    /** node.operit 在归档内的安装目录（正斜杠） */
+    nodeOperitArchiveDir: string;
+}
+/** 相对引用 -> 归档路径。越界的 .. 直接丢弃，与运行时 normalizePath 的行为一致。 */
+export declare function resolveRelative(fromArchive: string, spec: string): string;
+export declare function rewriteModule(env: RewriteEnv, archivePath: string, source: string): RewriteOutcome;

package/dist/lib/rewrite.js

@@ -0,0 +1,197 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelative = resolveRelative;
+exports.rewriteModule = rewriteModule;
+/**
+ * 裸名重写：把 require 的目标改写成「归档内的显式 .js 相对路径」。
+ *
+ * 三条规则（与 node.operit 的 BUILTINS.json 契约一致）：
+ *   1. 运行时已内建的裸名（lodash / uuid / axios）保持原样；
+ *   2. 其余 Node 内建 -> node.operit 的 dist 子路径；status 为 planned/unsupported 的直接构建失败；
+ *   3. 第三方 npm 包 -> 该包入口文件（解析 main / exports）。
+ *
+ * 为什么必须显式带 .js：运行时的 buildCandidatePaths 对命中扩展名正则的名字只试一个候选、
+ * 不补扩展名。包名里的 ".operit" 正好命中那个正则，所以 ".../node.operit" 会被当成完整路径而解析失败。
+ *
+ * 全程在「归档路径空间」里工作：不传项目目录，也不需要知道磁盘布局 ——
+ * 归档路径与磁盘路径的对应关系由 env.locate 负责，这样 TS 模式的产物目录映射能透明接进来。
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const contract_1 = require("./contract");
+const js_requires_1 = require("./js-requires");
+const EXTENSION_RE = /\.[a-z0-9]+$/i;
+function toPosix(value) {
+    return value.replace(/\\/g, '/');
+}
+/** 归档路径的目录部分（'' 表示归档根）。 */
+function dirOf(archivePath) {
+    const index = archivePath.lastIndexOf('/');
+    return index < 0 ? '' : archivePath.slice(0, index);
+}
+/** 相对引用 -> 归档路径。越界的 .. 直接丢弃，与运行时 normalizePath 的行为一致。 */
+function resolveRelative(fromArchive, spec) {
+    const joined = (dirOf(fromArchive) === '' ? '' : dirOf(fromArchive) + '/') + toPosix(spec);
+    const stack = [];
+    for (const part of joined.split('/')) {
+        if (part === '' || part === '.')
+            continue;
+        if (part === '..') {
+            stack.pop();
+            continue;
+        }
+        stack.push(part);
+    }
+    return stack.join('/');
+}
+/**
+ * 目标文件相对当前文件的引用写法。
+ *
+ * 只有真正需要时才补 "./"：已经是 "../" 开头时再补会得到 "./../x"，
+ * 运行时的 normalizePath 虽然能吃掉它，但产出会显得很不专业。
+ */
+function relativeSpec(fromArchive, target) {
+    const relative = toPosix(node_path_1.posix.relative(dirOf(fromArchive), target));
+    return relative.startsWith('.') ? relative : './' + relative;
+}
+/** 依次尝试 原样 / .js / .json / /index.js；命中已存在的则返回归档路径。 */
+function withCandidates(env, archivePath) {
+    const attempts = EXTENSION_RE.test(archivePath)
+        ? [archivePath]
+        : [archivePath, archivePath + '.js', archivePath + '.json', archivePath + '/index.js'];
+    for (const attempt of attempts) {
+        if (env.locate(attempt) !== null) {
+            return attempt;
+        }
+    }
+    return null;
+}
+function readJson(path) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** 从 exports 的某个值里挑出 CommonJS 能用的那个（require > node > default > import）。 */
+function pickCondition(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === null || typeof value !== 'object')
+        return null;
+    const record = value;
+    for (const key of ['require', 'node', 'default', 'import']) {
+        const picked = pickCondition(record[key]);
+        if (picked !== null)
+            return picked;
+    }
+    return null;
+}
+function resolveExports(exportsField, subpath) {
+    if (exportsField === undefined || exportsField === null)
+        return null;
+    if (typeof exportsField === 'string') {
+        return subpath === '' ? exportsField : null;
+    }
+    if (typeof exportsField !== 'object')
+        return null;
+    const record = exportsField;
+    const keys = Object.keys(record);
+    if (!keys.some((key) => key.startsWith('.'))) {
+        return subpath === '' ? pickCondition(exportsField) : null;
+    }
+    const wanted = subpath === '' ? '.' : './' + subpath;
+    const direct = pickCondition(record[wanted]);
+    if (direct !== null)
+        return direct;
+    for (const key of keys) {
+        if (!key.includes('*'))
+            continue;
+        const starIndex = key.indexOf('*');
+        const prefix = key.slice(0, starIndex);
+        const suffix = key.slice(starIndex + 1);
+        if (!wanted.startsWith(prefix) || !wanted.endsWith(suffix))
+            continue;
+        const middle = wanted.slice(prefix.length, wanted.length - suffix.length);
+        const template = pickCondition(record[key]);
+        if (template !== null)
+            return template.replace('*', middle);
+    }
+    return null;
+}
+/** 裸包名 -> 归档内的入口文件。 */
+function resolvePackageEntry(env, spec) {
+    const segments = spec.split('/');
+    const isScoped = spec.startsWith('@');
+    const packageName = isScoped ? segments.slice(0, 2).join('/') : segments[0];
+    const subpath = segments.slice(isScoped ? 2 : 1).join('/');
+    const packageDir = 'node_modules/' + packageName;
+    const manifestDisk = env.locate(packageDir + '/package.json');
+    if (manifestDisk === null) {
+        return null;
+    }
+    const manifest = readJson(manifestDisk);
+    let relative = manifest === null ? null : resolveExports(manifest.exports, subpath);
+    if (relative === null && subpath === '' && manifest !== null && typeof manifest.main === 'string') {
+        relative = manifest.main;
+    }
+    if (relative === null) {
+        relative = subpath === '' ? 'index.js' : subpath;
+    }
+    return withCandidates(env, packageDir + '/' + toPosix(relative));
+}
+function rewriteModule(env, archivePath, source) {
+    const sites = (0, js_requires_1.findRequires)(source);
+    const diagnostics = [];
+    const errors = [];
+    const discovered = [];
+    // 从后往前替换：前面的改动不影响后面的下标
+    let output = source;
+    for (let index = sites.length - 1; index >= 0; index -= 1) {
+        const site = sites[index];
+        const spec = site.spec;
+        if (contract_1.RUNTIME_BUILTINS.includes(spec)) {
+            diagnostics.push({ file: archivePath, spec, kind: 'untouched', target: spec });
+            continue;
+        }
+        if (spec.startsWith('./') || spec.startsWith('../') || spec.startsWith('/')) {
+            const resolved = withCandidates(env, resolveRelative(archivePath, spec));
+            if (resolved === null) {
+                errors.push(archivePath + ' 里 require(\'' + spec + '\') 解析不到文件');
+                continue;
+            }
+            diagnostics.push({ file: archivePath, spec, kind: 'relative', target: resolved });
+            discovered.push(resolved);
+            output = output.slice(0, site.start) + relativeSpec(archivePath, resolved) + output.slice(site.end);
+            continue;
+        }
+        const builtin = env.contract.builtins[spec];
+        if (builtin !== undefined) {
+            if (builtin.status === 'planned' || builtin.status === 'unsupported') {
+                errors.push(archivePath + ' 依赖 ' + spec + '，契约里它是 ' + builtin.status + '，构建中止。\n' +
+                    '    原因：' + (builtin.note === undefined ? '（契约未注明）' : builtin.note));
+                continue;
+            }
+            const target = env.nodeOperitArchiveDir + '/' + env.contract.distDir + '/' + builtin.subpath + '.js';
+            if (env.locate(target) === null) {
+                errors.push(archivePath + ' 依赖 ' + spec + '，但归档里找不到 ' + target + '（node.operit 装得不完整？）');
+                continue;
+            }
+            diagnostics.push({ file: archivePath, spec, kind: 'builtin', target });
+            discovered.push(target);
+            output = output.slice(0, site.start) + relativeSpec(archivePath, target) + output.slice(site.end);
+            continue;
+        }
+        const packageEntry = resolvePackageEntry(env, spec);
+        if (packageEntry === null) {
+            errors.push(archivePath + ' 里 require(\'' + spec + '\') 既不是 Node 内建、也不在 node_modules 里。\n' +
+                '    契约表里没有这个名字，node_modules/' + spec + ' 也不存在。');
+            continue;
+        }
+        diagnostics.push({ file: archivePath, spec, kind: 'package', target: packageEntry });
+        discovered.push(packageEntry);
+        output = output.slice(0, site.start) + relativeSpec(archivePath, packageEntry) + output.slice(site.end);
+    }
+    return { code: output, diagnostics, errors, discovered };
+}

package/dist/lib/typescript.d.ts

@@ -0,0 +1,23 @@
+import { dirname } from 'node:path';
+export interface TypeScriptPlan {
+    /** 是否 TS 工程 */
+    isTypeScript: boolean;
+    /** tsconfig 的绝对路径（isTypeScript 为 false 时为空串） */
+    tsconfigPath: string;
+    /** 编译产物目录（绝对路径）；null 表示与源码同目录 */
+    outDir: string | null;
+}
+export declare function planTypeScript(projectDir: string): TypeScriptPlan;
+/**
+ * 调用 tsc 编译。
+ *
+ * 输出重定向到**临时文件**而不是管道：某些受限环境不允许通过管道捕获子进程输出
+ * （会直接 EPERM），而这里必须拿到编译日志才能报错。临时文件两边都能用。
+ */
+export declare function compileTypeScript(projectDir: string, tsconfigPath: string): {
+    ok: boolean;
+    output: string;
+};
+/** 归档路径 -> 磁盘文件；按 原样 -> 产物目录 -> 逐级剥前导段 依次尝试。 */
+export declare function createLocator(projectDir: string, outDir: string | null): (archivePath: string) => string | null;
+export { dirname };