Implement fetch API and Promise polyfills for ES5 JavaScript engine

[Copilot]

Enables modern JavaScript patterns (fetch, Promise, async/await via compilation) in the ES5 Nashorn engine without requiring Node.js, bridging to the existing Vert.x HTTP client infrastructure.

Implementation

Core Polyfills (fetch-runtime.js)

• Promise/A+: Complete ES5 implementation with then, catch, finally, all, race, resolve, reject
• Fetch API: Standard interface supporting all HTTP methods, request options, and response parsing (text, json, arrayBuffer)
• HTTP Status Mapping: Proper status text for common codes (200 OK, 404 Not Found, etc.)

Bridge Layer (JsFetchBridge.java)

• Maps fetch API calls to existing JsHttpClient
• Inherits SSRF protection and proxy support
• Returns JsHttpResponse objects for seamless integration

Auto-Injection

• Modified JsParserExecutor and JsPlaygroundExecutor to load fetch runtime on engine initialization
• Lazy-loaded and cached for performance
• Coexists with existing http object (no breaking changes)

Usage

Users can now write:

function parse(shareLinkInfo, http, logger) {
    fetch("https://api.example.com/data")
        .then(function(response) { return response.json(); })
        .then(function(data) { return data.downloadUrl; })
        .catch(function(err) { logger.error(err.message); });
}

With frontend TypeScript compilation (documented but not implemented), this enables:

async function parse(info: ShareLinkInfo): Promise<string> {
    const response = await fetch("https://api.example.com/data");
    const data = await response.json();
    return data.downloadUrl;
}

Files

New:

• parser/src/main/resources/fetch-runtime.js - Promise + fetch polyfills
• parser/src/main/java/cn/qaiu/parser/customjs/JsFetchBridge.java - Java bridge
• parser/src/main/resources/custom-parsers/fetch-demo.js - Example usage
• parser/src/test/java/cn/qaiu/parser/customjs/JsFetchBridgeTest.java - Tests
• parser/doc/TYPESCRIPT_*.md - Documentation

Modified:

• JsParserExecutor.java - Auto-inject fetch runtime
• JsPlaygroundExecutor.java - Auto-inject fetch runtime

Original prompt

可以实现，而且不需要 Node 环境，整体可以做成纯前端编译 + 后端保持 ES5 引擎 + 适配已有 Vert.x JS 兼容层的方案。

我先用一句话总结，再分步骤说实现思路，最后单独讲 fetch→Vert.x client 的适配。

---

总体方案概览

• 浏览器端：
  • 引入纯 JS 的 typescript.js（官方 tsc 编译器浏览器版）。
  • 用户在浏览器里写 TS / ES6+ 代码，使用 async/await 和标准 fetch。
  • 使用 tsc 在浏览器里实时编译成 ES5 JS。
• 后端（Java + ES5.1 引擎）：
  • 仍然跑 ES5 代码，不需要 Node。
  • 在“Vert.x client JS 兼容层”上再包一层，让前端编译输出中的 fetch 调用，最终走你已经实现的 Vert.x HTTP 客户端。

核心要点有三个：

1. 浏览器里的 tsc 如何配置生成 ES5。
2. 如何在浏览器端把 fetch 封装成“你后端已经实现的 HTTP 接口调用”。
3. 生成的 JS 如何与已有 Vert.x JS 兼容层对接。

---

一、浏览器引入纯 JS 版 tsc（TypeScript 官方编译器）

1. 引入方式

最简单做法：用官方打包好的 typescript.js 或自己用 bundler 打包一份，放在 webroot 之类的静态目录中：

<script src="/static/ts/typescript.js"></script>
<script>
  // 全局会有 ts 对象
  console.log(ts.version);
</script>

2. 在浏览器内编译 TS/ES6 → ES5

示例代码：

function compileToES5(sourceCode, fileName) {
  const result = ts.transpileModule(sourceCode, {
    compilerOptions: {
      target: ts.ScriptTarget.ES5,      // 生成 ES5
      module: ts.ModuleKind.None,       // 看你后端如何加载；如果是 eval 直接跑，用 None
      lib: ["es5", "dom"],              // 浏览器环境
      experimentalDecorators: true,     // 如需
      emitDecoratorMetadata: false
    },
    fileName: fileName || "script.ts"
  });

  return {
    js: result.outputText,
    diagnostics: result.diagnostics
  };
}

用户在页面上写脚本，比如 textarea / Monaco 编辑器，然后：

const src = editor.getValue(); // TS/ES6 代码
const { js, diagnostics } = compileToES5(src);
if (diagnostics && diagnostics.length) {
  // 把类型错误/语法错误显示给用户
}
uploadCompiledScript(js); // 把 ES5 发给后端存储 / 执行

这样后端完全只接触到已经降级好的 ES5 源码，不需要 Node，也不用自己在后端做编译。

---

二、fetch 与 Vert.x client JS 兼容层的衔接

你现在有“vertx client js 兼容层”，本质上应该是：

• 在 Java 的 JS 引擎里，注入了一个或多个对象/函数，用于发 HTTP 请求，比如：
  • httpClient.get(url, callback)
  • 或 VertxHttp.request(method, url, options, callback)
• 脚本里目前是直接调用这些方法。

你想做到的是：

脚本作者只写标准 fetch(url, options)，
编译后，仍然使用你那套 Vert.x client 实现。

这里有两个可行路线，建议用第 1 种：

方案 1：后端注入 fetch，前端 TS 只当它是浏览器 API

流程：

1. 浏览器编译 TS 时，把 lib 配置中包含 dom，TS 会认为全局有 fetch：

   lib: ["es5", "dom"]

2. 编译出来的 JS 里，fetch 调用还是 fetch(...)，保持原样。
3. 在 Java 端脚本执行环境中，自己实现一个全局 fetch 函数，内部调用 Vert.x client。

示例（Java 伪码）：

public class JsFetchBridge {
    private final HttpClient client;

    public JsFetchBridge(HttpClient client) {
        this.client = client;
    }

    // 简化：同步调用，返回一个 POJO，JS 侧再包 Promise
    public Map<String, Object> fetch(String url, Map<String, Object> options) {
        // 从 options 解析 method / headers / body 等，调用 Vert.x 客户端
        // 这里只演示结构
        String method = (String) options.getOrDefault("method", "GET");
        // ... 构造 Vert.x 请求 ...

        // 同步等待响应（或用阻塞式 API）
        // VertxWebClientResponse resp = ...

        Map<String, Object> result = new HashMap<>();
        result.put("status", /*resp.statusCode()*/ 200);
        result.put("body", /*resp.bodyAsString()*/ "");
        // headers 等视情况返回
        return result;
    }
}

在 JS 引擎里注入：

ScriptEngine engine = ...;
Bindings bindings = engine.getBindings(ScriptContext.ENGINE_SCOPE);
bindings.put("JavaFetch", new JsFetchBridge(vertxHttpClient));
engine.eval(fetchRuntimeJs); // 下一段里的 JS 代码

fetchRuntimeJs（用 ES5 写，适配你引擎只支持 ES5）：

// 简单 Promise 实现（如果你环境已有 Promise 就不需要）
function SimplePromise(executor) {
  var state = 'pending';
  var value;
  var handlers = [];

  function resolve(result) {
    if (state !== 'pending') return;
    state = 'fulfilled';
    value = result;
    handlers.forEach(handle);
    handlers = null;
  }

  function reject(err) {
    if (state !== 'pending') return;
    state = 'rejected';
    value = err;
    handlers.forEach(handle);
    handlers = null;
  }

  function handle(handler) {
    if (state === 'pending') {
      handlers.push(handler);
    } else {
      if (state === 'fulfilled' && typeof handler.onFulfilled === 'function') {
        handler.onFulfilled(value);
      }
      if (state === 'rejected' && typeof handler.onRejected === 'function') {
        handler.onRejected(value);
      }
    }
  }

  this.then = function(onFulfilled, onRejected) {
    return new SimplePromise(function(resolveNext, rejectNext) {
      handle({
        onFulfilled: function(val) {
          if (!onFulfilled) { resolveNext(val); return; }
          try {
            var res = onFulfilled(val);
            resolveNext(res);
          } catch (e) {
            rejectNext(e);
          }
        },
        onRejected: function(err) {
          if (!onRejected) { rejectNext(err); return; }
          try {
            var res = onRejected(err);
            resolveNext(res);
          } catch (e) {
            rejectNext(e);
          }
        }
      });
    });
  };

  try {
    executor(resolve, reject);
  } catch (e) {
    reject(e);
  }
}

// 标准 fetch 接口的最小实现
function fetch(url, options) {
  return new SimplePromise(function(resolve, reject) {
    try {
      var res = JavaFetch.fe...

</details>



<!-- START COPILOT CODING AGENT TIPS -->
---

✨ Let Copilot coding agent [set things up for you](https://github.com/qaiu/netdisk-fast-download/issues/new?title=✨+Set+up+Copilot+instructions&body=Configure%20instructions%20for%20this%20repository%20as%20documented%20in%20%5BBest%20practices%20for%20Copilot%20coding%20agent%20in%20your%20repository%5D%28https://gh.io/copilot-coding-agent-tips%29%2E%0A%0A%3COnboard%20this%20repo%3E&assignees=copilot) — coding agent works faster and does higher quality work when set up for your repo.

[qaiu]

前端部分，js演练场未修改，需要引入ts编译器