quickwin 1.2.1 → 2.0.0

package/lib/http-server.ts

@@ -1,6 +1,7 @@
 import './polyfill.js'
 import * as sock from 'sock'
 import { HeadersImpl, RequestImpl, ResponseImpl, _readStream } from './http-common.js'
+import { AbortController } from './abort.js'
 
 type SockHandle = import('sock').SockHandle
 
@@ -36,10 +37,14 @@ interface Conn {
     pending: PendingReq | null
     current: ActiveReq | null
     outQueue: Uint8Array | null
+    resumeRead: (() => void) | null
     closed: boolean
     closeAfterFlush: boolean
     keepAlive: boolean
     owner: HttpServer
+    /** AbortController for the request currently served on this connection,
+     *  aborted when the client disconnects mid-response. */
+    ac: AbortController | null
 }
 
 const STATUS_TEXT: Record<number, string> = {
@@ -74,6 +79,20 @@ function findCrLfCrLf(buf: Uint8Array): number {
     return -1
 }
 
+/** Flatten a `HeadersInit` into `[name, value]` pairs, preserving the
+ *  casing the caller provided (Node `addTrailers` semantics). */
+function headersInitToPairs(init: HeadersInit): [string, string][] {
+    if (init instanceof HeadersImpl) {
+        const out: [string, string][] = []
+        for (const [name, value] of init) out.push([name, value])
+        return out
+    }
+    if (Array.isArray(init)) return init.map(([name, value]) => [name, String(value)])
+    const out: [string, string][] = []
+    for (const name of Object.keys(init)) out.push([name, String((init as Record<string, string>)[name])])
+    return out
+}
+
 /** Decode a chunked-transfer body starting at `start`. Returns the decoded
  *  data and the offset just past the terminating CRLF, or null if the buffer
  *  does not yet contain the complete chunked body. */
@@ -196,10 +215,12 @@ export class HttpServer {
                 pending: null,
                 current: null,
                 outQueue: null,
+                resumeRead: null,
                 closed: false,
                 closeAfterFlush: false,
                 keepAlive: true,
                 owner: this,
+                ac: null,
             }
             this.conns.set(c.sock, c)
             sock.set_on_event(c.sock, (event: NetEvent) => this.onConnEvent(c, event))
@@ -212,7 +233,8 @@ export class HttpServer {
         if (event.lNetworkEvents & sock.FdEvent.FD_WRITE) flushQueue(c)
         if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
             onRead(c)
-            if (!c.current && !c.pending) closeConn(c)
+            abortConn(c)
+            closeConn(c)
         }
     }
 }
@@ -233,48 +255,137 @@ function onRead(c: Conn): void {
     if (!c.closed) tryProcess(c)
 }
 
-function queueSend(c: Conn, data: Uint8Array): void {
-    if (c.closed || data.length === 0) return
+/** Send `data`, or queue it when the kernel send buffer is full.
+ *  Returns true when the data was fully handed to the kernel, or false
+ *  when it has been buffered (or partially handed over) and the caller
+ *  should back off until `flushQueue` drains and calls `c.resumeRead`. */
+function queueSend(c: Conn, data: Uint8Array): boolean {
+    if (c.closed || data.length === 0) return true
     if (c.outQueue && c.outQueue.length > 0) {
         c.outQueue = concatU8([c.outQueue, data])
-        return
+        return false
     }
     const ret = sock.send(c.sock, toArrayBuffer(data))
     if (ret < 0) {
-        c.outQueue = data
-        return
+        abortConn(c)
+        closeConn(c)
+        return true
     }
     if (ret < data.length) {
         c.outQueue = data.subarray(ret)
-        return
+        return false
     }
-    if (c.closeAfterFlush) closeConn(c)
+    return true
 }
 
 function flushQueue(c: Conn): void {
     if (c.closed) return
     if (!c.outQueue || c.outQueue.length === 0) {
         if (c.closeAfterFlush) closeConn(c)
+        else resumeReader(c)
         return
     }
     const q = c.outQueue
     const ret = sock.send(c.sock, toArrayBuffer(q))
-    if (ret < 0) return
+    if (ret < 0) {
+        abortConn(c)
+        closeConn(c)
+        return
+    }
     if (ret < q.length) {
         c.outQueue = q.subarray(ret)
         return
     }
     c.outQueue = null
     if (c.closeAfterFlush) closeConn(c)
+    else resumeReader(c)
 }
 
 function closeConn(c: Conn): void {
     if (c.closed) return
     c.closed = true
+    resumeReader(c)
     if (c.sock >= 0) sock.closesocket(c.sock)
     c.owner.conns.delete(c.sock)
 }
 
+/** Abort the in-flight request (notifying its handler via `req.signal`).
+ *  Safe to call when idle or already aborted: the controller is cleared so
+ *  a fresh request on this connection gets a fresh signal. */
+function abortConn(c: Conn): void {
+    const ac = c.ac
+    c.ac = null
+    if (ac) ac.abort()
+}
+
+/** Resolve the pending back-pressure awaiter, if any. Called whenever the
+ *  send queue drains or the connection closes. */
+function resumeReader(c: Conn): void {
+    const r = c.resumeRead
+    c.resumeRead = null
+    if (r) r()
+}
+
+/** Close the connection once a response is fully flushed, when the
+ *  handler or client asked for `Connection: close`. */
+function finishResponse(c: Conn): void {
+    if (c.closeAfterFlush && !c.outQueue) closeConn(c)
+}
+
+/** Frame `data` as a single chunked-transfer block: `<hex size>\r\n<data>\r\n`. */
+function encodeChunkFrame(data: Uint8Array, enc: TextEncoder): Uint8Array {
+    return concatU8([enc.encode(data.byteLength.toString(16) + '\r\n'), data, enc.encode('\r\n')])
+}
+
+/** Read `body` one chunk at a time and send it out. When the kernel send
+ *  buffer fills up (`queueSend` returns false) we pause on `c.resumeRead`,
+ *  which `flushQueue` resumes once the socket drains — backpressure. */
+async function writeStreamingBody(c: Conn, body: ReadableStream<Uint8Array> | null, chunked: boolean, trailer: Promise<HeadersInit> | undefined): Promise<void> {
+    if (c.closed || body == null) return
+    const reader = body.getReader()
+    const enc = new TextEncoder()
+    try {
+        while (!c.closed) {
+            const { done, value } = await reader.read()
+            if (done) break
+            if (value && value.byteLength > 0) {
+                const frame = chunked ? encodeChunkFrame(value, enc) : value
+                if (!queueSend(c, frame)) {
+                    await new Promise<void>((resolve) => { c.resumeRead = resolve })
+                }
+            }
+        }
+        if (c.closed) {
+            // 客户端断开（FD_CLOSE / send 失败）：取消响应体，让 producer 感知
+            //（exec_server 借此 kill 子进程），而不是干等它自然结束。
+            try { await reader.cancel() } catch (e) {
+                console.error('[http-server] body cancel error:', e)
+            }
+            return
+        }
+        if (chunked) {
+            let terminator = '0\r\n\r\n'
+            if (trailer) {
+                try {
+                    const pairs = headersInitToPairs(await trailer)
+                    if (pairs.length > 0) {
+                        let s = '0\r\n'
+                        for (const [name, value] of pairs) s += name + ': ' + value + '\r\n'
+                        s += '\r\n'
+                        terminator = s
+                    }
+                } catch (e) {
+                    console.error('[http-server] trailers promise rejected:', e)
+                }
+            }
+            queueSend(c, enc.encode(terminator))
+        }
+        finishResponse(c)
+    } finally {
+        reader.releaseLock()
+    }
+}
+
 // ── Request state machine ──
 
 function whole(c: Conn): Uint8Array {
@@ -355,12 +466,15 @@ function dispatchRequest(c: Conn, parsed: ParsedHeader, body: Uint8Array, end: n
     const isAbsolute = parsed.target.startsWith('http://') || parsed.target.startsWith('https://')
     const url = isAbsolute ? parsed.target : 'http://' + host + parsed.target
 
+    const ac = new AbortController()
     const req = new RequestImpl(url, {
         method: parsed.method,
         headers: new HeadersImpl(parsed.headers),
         body: body.length > 0 ? body : undefined,
+        signal: ac.signal,
     })
 
+    c.ac = ac
     c.current = { req }
     trimParts(c, whole(c), end)
     void handleRequest(c)
@@ -385,40 +499,77 @@ async function handleRequest(c: Conn): Promise<void> {
     }
 
     if (c.closed) return
-    await sendResponse(c, req.method, res)
+    try {
+        await sendResponse(c, req.method, res)
+    } catch (e) {
+        console.error('[http-server] response send error:', e)
+        if (!c.closed) closeConn(c)
+        return
+    }
     if (c.closed) return
 
     c.current = null
     if (!c.closeAfterFlush) tryProcess(c)
 }
 
+function buildHead(status: number, statusText: string, headers: HeadersImpl): Uint8Array {
+    let head = 'HTTP/1.1 ' + status + ' ' + statusText + '\r\n'
+    for (const [name, value] of headers) head += name + ': ' + value + '\r\n'
+    head += '\r\n'
+    return new TextEncoder().encode(head)
+}
+
 async function sendResponse(c: Conn, method: string, res: Response): Promise<void> {
     const status = res.status
     const statusText = res.statusText || STATUS_TEXT[status] || 'OK'
     const headers = new HeadersImpl(res.headers)
 
-    let body: Uint8Array
-    try {
-        body = await _readStream(res.body)
-    } catch {
-        body = new Uint8Array(0)
-    }
-    if (c.closed) return
-
     const headOnly = method === 'HEAD'
     const bodyless = (status >= 100 && status < 200) || status === 204 || status === 304
 
-    if (!headers.has('content-length') && !bodyless) headers.set('Content-Length', String(body.length))
     if (!headers.has('connection')) headers.set('Connection', c.keepAlive ? 'keep-alive' : 'close')
-
     const connHdr = (headers.get('connection') || '').toLowerCase()
     if (!c.keepAlive || connHdr === 'close') c.closeAfterFlush = true
 
-    let head = 'HTTP/1.1 ' + status + ' ' + statusText + '\r\n'
-    for (const [name, value] of headers) head += name + ': ' + value + '\r\n'
-    head += '\r\n'
+    if (bodyless) {
+        headers.delete('Transfer-Encoding')
+        headers.delete('Content-Length')
+        headers.delete('Trailer')
+        queueSend(c, buildHead(status, statusText, headers))
+        finishResponse(c)
+        return
+    }
 
-    const headBytes = new TextEncoder().encode(head)
-    const payload = headOnly || body.length === 0 ? headBytes : concatU8([headBytes, body])
-    queueSend(c, payload)
+    if (headOnly) {
+        headers.delete('Transfer-Encoding')
+        headers.delete('Trailer')
+        if (!headers.has('content-length')) {
+            try {
+                const full = await _readStream(res.body)
+                headers.set('Content-Length', String(full.length))
+            } catch { /* leave length unspecified */ }
+        }
+        if (c.closed) return
+        queueSend(c, buildHead(status, statusText, headers))
+        finishResponse(c)
+        return
+    }
+
+    // Body is streamed out chunk by chunk. A declared Content-Length sends
+    // the bytes as-is; otherwise we use chunked framing.
+    const chunked = (headers.get('transfer-encoding') || '').toLowerCase() === 'chunked' ||
+        !headers.has('content-length')
+    // Trailing headers are only emitted when the body is chunk-framed and a
+    // `Trailer` declaration header is present (Node addTrailers semantics).
+    const trailerDeclared = (headers.get('trailer') || '').trim().length > 0
+    if (chunked) {
+        headers.delete('Content-Length')
+        if (!headers.has('transfer-encoding')) headers.set('Transfer-Encoding', 'chunked')
+        if (!trailerDeclared) headers.delete('Trailer')
+    } else {
+        headers.delete('Transfer-Encoding')
+        headers.delete('Trailer')
+    }
+    queueSend(c, buildHead(status, statusText, headers))
+    await writeStreamingBody(c, res.body, chunked, (chunked && trailerDeclared) ? res.trailers : undefined)
 }

package/lib/react-qw/components/DateTimePicker.js

@@ -1,29 +1,21 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef, useRef, useEffect, useState } from 'react';
 import * as gui from 'gui';
-import * as ffi from 'ffi';
-function readI16(ptr, offset) {
-    return ffi.readByte(ptr + offset) | (ffi.readByte(ptr + offset + 1) << 8);
-}
-function readI32(ptr, offset) {
-    return ffi.readByte(ptr + offset) | (ffi.readByte(ptr + offset + 1) << 8) |
-        (ffi.readByte(ptr + offset + 2) << 16) | (ffi.readByte(ptr + offset + 3) << 24);
-}
-function bufPtr(buf) {
-    return ffi.bufferPtr(buf);
-}
+import { InvalidateRect } from '../../windows/user32.js';
+import { NULL } from '../../ffi/ctype.js';
+import { SYSTEMTIME, NMDATETIMECHANGE } from '../../windows/structs.js';
+import { nmCode } from '../nmhdr.js';
 function dateToSysTimeBuf(d) {
-    const buf = new ArrayBuffer(16);
-    const dv = new DataView(buf);
-    dv.setUint16(0, d.getFullYear(), true);
-    dv.setUint16(2, d.getMonth() + 1, true);
-    dv.setUint16(4, 0, true); // wDayOfWeek (ignored on set)
-    dv.setUint16(6, d.getDate(), true);
-    dv.setUint16(8, d.getHours(), true);
-    dv.setUint16(10, d.getMinutes(), true);
-    dv.setUint16(12, d.getSeconds(), true);
-    dv.setUint16(14, d.getMilliseconds(), true);
-    return buf;
+    // wDayOfWeek 设置时被忽略，缺省跳过 = 0
+    return SYSTEMTIME.encode({
+        wYear: d.getFullYear(),
+        wMonth: d.getMonth() + 1,
+        wDay: d.getDate(),
+        wHour: d.getHours(),
+        wMinute: d.getMinutes(),
+        wSecond: d.getSeconds(),
+        wMilliseconds: d.getMilliseconds(),
+    });
 }
 const DateTimePicker = forwardRef(function DateTimePicker({ value, onChange, defaultValue, format = 'short', allowNone, updown, style }, ref) {
     const [internalDate, setInternalDate] = useState(defaultValue ?? null);
@@ -48,7 +40,7 @@ const DateTimePicker = forwardRef(function DateTimePicker({ value, onChange, def
         const d = effectiveDate;
         if (d) {
             const buf = dateToSysTimeBuf(d);
-            gui.SendMessage(h, 4098 /* gui.DtMsg.SETSYSTEMTIME */, 0 /* gui.DtFlag.GDT_VALID */, bufPtr(buf));
+            gui.SendMessage(h, 4098 /* gui.DtMsg.SETSYSTEMTIME */, 0 /* gui.DtFlag.GDT_VALID */, buf.ptr);
         }
         else {
             gui.SendMessage(h, 4098 /* gui.DtMsg.SETSYSTEMTIME */, 1 /* gui.DtFlag.GDT_NONE */, 0);
@@ -58,7 +50,7 @@ const DateTimePicker = forwardRef(function DateTimePicker({ value, onChange, def
         const h = dpRef.current;
         if (!h)
             return;
-        gui.InvalidateRect(h, null, true);
+        InvalidateRect(h, NULL, 1);
         // 发送 WM_SIZE 让控件（尤其是 DTS_UPDOWN）重新布局内部子窗口
         const cr = gui.GetClientRect(h);
         if (cr) {
@@ -69,22 +61,17 @@ const DateTimePicker = forwardRef(function DateTimePicker({ value, onChange, def
     }, []);
     return (_jsx("w", { type: "STATIC", ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 33554432 /* gui.WindowStyle.CLIPCHILDREN */, style: { ...style, flexDirection: 'column', alignItems: 'stretch' }, ref: ref, onEvent: (e) => {
             if (e.msg === 78 /* gui.WmMsg.NOTIFY */) {
-                const code = readI32(e.lParam, 16);
+                const code = nmCode(e.lParam);
                 if (code === -759 /* gui.DtNotifyCode.DATETIMECHANGE */) {
-                    const dwFlags = readI32(e.lParam, 24);
+                    // NMDATETIMECHANGE: NMHDR + DWORD dwFlags + SYSTEMTIME st
+                    const { dwFlags, st } = NMDATETIMECHANGE.decode(e.lParam);
                     if (dwFlags === 1 /* gui.DtFlag.GDT_NONE */) {
                         if (!isControlled)
                             setInternalDate(null);
                         onChangeRef.current?.(null);
                     }
                     else {
-                        const year = readI16(e.lParam, 28);
-                        const month = readI16(e.lParam, 30);
-                        const day = readI16(e.lParam, 34);
-                        const hour = readI16(e.lParam, 36);
-                        const min = readI16(e.lParam, 38);
-                        const sec = readI16(e.lParam, 40);
-                        const d = new Date(year, month - 1, day, hour, min, sec);
+                        const d = new Date(st.wYear, st.wMonth - 1, st.wDay, st.wHour, st.wMinute, st.wSecond);
                         if (!isControlled)
                             setInternalDate(d);
                         onChangeRef.current?.(d);

package/lib/react-qw/components/Input.js

@@ -1,14 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef, useState, useRef, useEffect } from 'react';
 import * as gui from 'gui';
-import * as ffi from 'ffi';
-function textToUtf16(s) {
-    const buf = new ArrayBuffer((s.length + 1) * 2);
-    const dv = new DataView(buf);
-    for (let i = 0; i < s.length; i++)
-        dv.setUint16(i * 2, s.charCodeAt(i), true);
-    return buf;
-}
+import { WCHAR } from '../../ffi/bind.js';
 export const Input = forwardRef(({ value: controlledValue, defaultValue = '', onChange, placeholder, password, multiline, readonly, number, disabled, style }, ref) => {
     const [internalValue, setInternalValue] = useState(defaultValue);
     const isControlled = controlledValue !== undefined;
@@ -27,8 +20,8 @@ export const Input = forwardRef(({ value: controlledValue, defaultValue = '', on
         const h = inputRef.current;
         if (!h || !placeholder)
             return;
-        const buf = textToUtf16(placeholder);
-        gui.SendMessage(h, 5377 /* gui.EditMsg.SETCUEBANNER */, 1, ffi.bufferPtr(buf));
+        const buf = WCHAR.encode(placeholder);
+        gui.SendMessage(h, 5377 /* gui.EditMsg.SETCUEBANNER */, 1, buf.ptr);
     }, [placeholder]);
     return (_jsx("w", { type: "EDIT", text: displayValue, ws: ws, style: style, disabled: disabled, ref: (h) => {
             inputRef.current = h;

package/lib/react-qw/components/Link.js

@@ -1,23 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef, useRef, useEffect } from 'react';
-import * as gui from 'gui';
-import * as ffi from 'ffi';
-function readI32(ptr, offset) {
-    return ffi.readByte(ptr + offset) | (ffi.readByte(ptr + offset + 1) << 8) |
-        (ffi.readByte(ptr + offset + 2) << 16) | (ffi.readByte(ptr + offset + 3) << 24);
-}
-function readUtf16(ptr, offset, maxWords) {
-    const chars = [];
-    for (let i = 0; i < maxWords; i++) {
-        const lo = ffi.readByte(ptr + offset + i * 2);
-        const hi = ffi.readByte(ptr + offset + i * 2 + 1);
-        const code = (hi << 8) | lo;
-        if (code === 0)
-            break;
-        chars.push(String.fromCharCode(code));
-    }
-    return chars.join('');
-}
+import { InvalidateRect } from '../../windows/user32.js';
+import { NULL } from '../../ffi/ctype.js';
+import { NMLINK } from '../../windows/structs.js';
+import { nmCode } from '../nmhdr.js';
 const Link = forwardRef(function Link({ href, children, onClick, style }, ref) {
     const displayText = children != null ? String(children) : (href ?? '');
     const linkText = href ? `<A HREF="${href}">${displayText}</A>` : displayText;
@@ -28,14 +14,13 @@ const Link = forwardRef(function Link({ href, children, onClick, style }, ref) {
         const h = linkRef.current;
         if (!h)
             return;
-        gui.InvalidateRect(h, null, true);
+        InvalidateRect(h, NULL, 1);
     }, [linkText]);
     return (_jsx("w", { type: "STATIC", ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 33554432 /* gui.WindowStyle.CLIPCHILDREN */, style: { ...style, flexDirection: 'column', alignItems: 'stretch' }, ref: ref, onEvent: (e) => {
             if (e.msg === 78 /* gui.WmMsg.NOTIFY */) {
-                const code = readI32(e.lParam, 16);
+                const code = nmCode(e.lParam);
                 if (code === -2 /* gui.SysLinkNotifyCode.CLICK */ || code === -4 /* gui.SysLinkNotifyCode.RETURN */) {
-                    const url = readUtf16(e.lParam, 136, 2048);
-                    onClickRef.current?.(url);
+                    onClickRef.current?.(NMLINK.decode(e.lParam).item.szUrl);
                 }
             }
         }, children: _jsx("w", { type: "SysLink", ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 65536 /* gui.WindowStyle.TABSTOP */, text: linkText, style: { flexGrow: 1 }, ref: (h) => { linkRef.current = h; } }) }));