@whatwg-node/server 0.10.0-alpha-20241125144944-df106a17746126e3c8089afa16af852a4483c8b3 → 0.10.0-alpha-20250205010145-5ab5edf75d82f8174c999dc970ad9a042ea5547d

package/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decompressedResponseMap = exports.nodeRequestResponseMap = exports.ServerAdapterRequestAbortSignal = void 0;
+exports.decompressedResponseMap = exports.nodeRequestResponseMap = void 0;
 exports.isAsyncIterable = isAsyncIterable;
 exports.normalizeNodeRequest = normalizeNodeRequest;
 exports.isReadable = isReadable;
@@ -69,40 +69,9 @@ function isRequestBody(body) {
     }
     return false;
 }
-class ServerAdapterRequestAbortSignal extends EventTarget {
-    aborted = false;
-    _onabort = null;
-    reason;
-    throwIfAborted() {
-        if (this.aborted) {
-            throw this.reason;
-        }
-    }
-    sendAbort() {
-        this.reason = new DOMException('This operation was aborted', 'AbortError');
-        this.aborted = true;
-        this.dispatchEvent(new Event('abort'));
-    }
-    get onabort() {
-        return this._onabort;
-    }
-    set onabort(value) {
-        this._onabort = value;
-        if (value) {
-            this.addEventListener('abort', value);
-        }
-        else {
-            this.removeEventListener('abort', value);
-        }
-    }
-    any(signals) {
-        return AbortSignal.any([...signals]);
-    }
-}
-exports.ServerAdapterRequestAbortSignal = ServerAdapterRequestAbortSignal;
 let bunNodeCompatModeWarned = false;
 exports.nodeRequestResponseMap = new WeakMap();
-function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
+function normalizeNodeRequest(nodeRequest, fetchAPI) {
     const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
     let fullUrl = buildFullUrl(rawRequest);
     if (nodeRequest.query) {
@@ -112,7 +81,6 @@ function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
         }
         fullUrl = url.toString();
     }
-    let signal;
     const nodeResponse = exports.nodeRequestResponseMap.get(nodeRequest);
     exports.nodeRequestResponseMap.delete(nodeRequest);
     let normalizedHeaders = nodeRequest.headers;
@@ -124,24 +92,12 @@ function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
             }
         }
     }
+    const controller = new AbortController();
     if (nodeResponse?.once) {
-        let sendAbortSignal;
-        // If ponyfilled
-        if (fetchAPI.Request !== globalThis.Request) {
-            const newSignal = new ServerAdapterRequestAbortSignal();
-            registerSignal?.(newSignal);
-            signal = newSignal;
-            sendAbortSignal = () => signal.sendAbort();
-        }
-        else {
-            const controller = new AbortController();
-            signal = controller.signal;
-            sendAbortSignal = () => controller.abort();
-        }
         const closeEventListener = () => {
-            if (signal && !signal.aborted) {
-                rawRequest.aborted = true;
-                sendAbortSignal();
+            if (!controller.signal.aborted) {
+                Object.defineProperty(rawRequest, 'aborted', { value: true });
+                controller.abort(nodeResponse.errored ?? undefined);
             }
         };
         nodeResponse.once('error', closeEventListener);
@@ -154,7 +110,7 @@ function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
         return new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
             headers: normalizedHeaders,
-            signal,
+            signal: controller.signal,
         });
     }
     /**
@@ -167,16 +123,16 @@ function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
     if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
         if (isRequestBody(maybeParsedBody)) {
             return new fetchAPI.Request(fullUrl, {
-                method: nodeRequest.method,
+                method: nodeRequest.method || 'GET',
                 headers: normalizedHeaders,
                 body: maybeParsedBody,
-                signal,
+                signal: controller.signal,
             });
         }
         const request = new fetchAPI.Request(fullUrl, {
-            method: nodeRequest.method,
+            method: nodeRequest.method || 'GET',
             headers: normalizedHeaders,
-            signal,
+            signal: controller.signal,
         });
         if (!request.headers.get('content-type')?.includes('json')) {
             request.headers.set('content-type', 'application/json; charset=utf-8');
@@ -221,16 +177,17 @@ It will affect your performance. Please check our Bun integration recipe, and av
                     rawRequest.destroy(e);
                 },
             }),
-            signal,
+            signal: controller.signal,
         });
     }
     // perf: instead of spreading the object, we can just pass it as is and it performs better
     return new fetchAPI.Request(fullUrl, {
         method: nodeRequest.method,
         headers: normalizedHeaders,
+        signal: controller.signal,
+        // @ts-expect-error - AsyncIterable is supported as body
         body: rawRequest,
         duplex: 'half',
-        signal,
     });
 }
 function isReadable(stream) {
@@ -276,13 +233,25 @@ async function sendAsyncIterable(serverResponse, asyncIterable) {
         if (closed) {
             break;
         }
-        if (!serverResponse
-            // @ts-expect-error http and http2 writes are actually compatible
-            .write(chunk)) {
-            if (closed) {
-                break;
+        const shouldBreak = await new Promise(resolve => {
+            if (!serverResponse
+                // @ts-expect-error http and http2 writes are actually compatible
+                .write(chunk, err => {
+                if (err) {
+                    resolve(true);
+                }
+            })) {
+                if (closed) {
+                    resolve(true);
+                    return;
+                }
+                serverResponse.once('drain', () => {
+                    resolve(false);
+                });
             }
-            await new Promise(resolve => serverResponse.once('drain', resolve));
+        });
+        if (shouldBreak) {
+            break;
         }
     }
     endResponse(serverResponse);
@@ -343,15 +312,15 @@ function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
         return;
     }
     if (isReadableStream(fetchBody)) {
-        return sendReadableStream(serverResponse, fetchBody);
+        return sendReadableStream(nodeRequest, serverResponse, fetchBody);
     }
     if (isAsyncIterable(fetchBody)) {
         return sendAsyncIterable(serverResponse, fetchBody);
     }
 }
-async function sendReadableStream(serverResponse, readableStream) {
+async function sendReadableStream(nodeRequest, serverResponse, readableStream) {
     const reader = readableStream.getReader();
-    serverResponse.req.once('error', err => {
+    nodeRequest?.once?.('error', err => {
         reader.cancel(err);
     });
     while (true) {
@@ -474,17 +443,24 @@ function createDeferredPromise() {
     };
 }
 function handleAbortSignalAndPromiseResponse(response$, abortSignal) {
+    if (abortSignal?.aborted) {
+        throw abortSignal.reason;
+    }
     if (isPromise(response$) && abortSignal) {
         const deferred$ = createDeferredPromise();
-        abortSignal.addEventListener('abort', function abortSignalFetchErrorHandler() {
+        function abortSignalFetchErrorHandler() {
             deferred$.reject(abortSignal.reason);
-        });
+        }
+        abortSignal.addEventListener('abort', abortSignalFetchErrorHandler, { once: true });
         response$
             .then(function fetchSuccessHandler(res) {
             deferred$.resolve(res);
         })
             .catch(function fetchErrorHandler(err) {
             deferred$.reject(err);
+        })
+            .finally(() => {
+            abortSignal.removeEventListener('abort', abortSignalFetchErrorHandler);
         });
         return deferred$.promise;
     }
@@ -547,7 +523,7 @@ function handleResponseDecompression(response, fetchAPI) {
     }
     return decompressedResponse;
 }
-const terminateEvents = ['SIGINT', 'SIGTERM', 'exit'];
+const terminateEvents = ['SIGINT', 'exit', 'SIGTERM'];
 const disposableStacks = new Set();
 let eventListenerRegistered = false;
 function ensureEventListenerForDisposableStacks() {
@@ -557,10 +533,7 @@ function ensureEventListenerForDisposableStacks() {
     eventListenerRegistered = true;
     for (const event of terminateEvents) {
         globalThis.process.once(event, function terminateHandler() {
-            return Promise.allSettled([...disposableStacks].map(stack => !stack.disposed &&
-                stack.disposeAsync().catch(e => {
-                    console.error('Error while disposing:', e);
-                })));
+            return Promise.allSettled([...disposableStacks].map(stack => !stack.disposed && stack.disposeAsync()));
         });
     }
 }

package/cjs/uwebsockets.js

@@ -9,7 +9,7 @@ const utils_js_1 = require("./utils.js");
 function isUWSResponse(res) {
     return !!res.onData;
 }
-function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
+function getRequestFromUWSRequest({ req, res, fetchAPI, controller, }) {
     const method = req.getMethod();
     let duplex;
     const chunks = [];
@@ -43,9 +43,9 @@ function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
     let getReadableStream;
     if (method !== 'get' && method !== 'head') {
         duplex = 'half';
-        signal.addEventListener('abort', () => {
+        controller.signal.addEventListener('abort', () => {
             stop();
-        });
+        }, { once: true });
         let readableStream;
         getReadableStream = () => {
             if (!readableStream) {
@@ -97,7 +97,7 @@ function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
         get body() {
             return getBody();
         },
-        signal,
+        signal: controller.signal,
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore - not in the TS types yet
         duplex,
@@ -171,14 +171,14 @@ function createWritableFromUWS(uwsResponse, fetchAPI) {
         },
     });
 }
-function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal, fetchAPI) {
+function sendResponseToUwsOpts(uwsResponse, fetchResponse, controller, fetchAPI) {
     if (!fetchResponse) {
         uwsResponse.writeStatus('404 Not Found');
         uwsResponse.end();
         return;
     }
     const bufferOfRes = fetchResponse._buffer;
-    if (signal.aborted) {
+    if (controller.signal.aborted) {
         return;
     }
     uwsResponse.cork(() => {
@@ -208,17 +208,17 @@ function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal, fetchAPI) {
     if (bufferOfRes || !fetchResponse.body) {
         return;
     }
-    signal.addEventListener('abort', () => {
+    controller.signal.addEventListener('abort', () => {
         if (!fetchResponse.body?.locked) {
-            fetchResponse.body?.cancel(signal.reason);
+            fetchResponse.body?.cancel(controller.signal.reason);
         }
-    });
+    }, { once: true });
     return fetchResponse.body
         .pipeTo(createWritableFromUWS(uwsResponse, fetchAPI), {
-        signal,
+        signal: controller.signal,
     })
         .catch(err => {
-        if (signal.aborted) {
+        if (controller.signal.aborted) {
             return;
         }
         throw err;

package/esm/createServerAdapter.js

@@ -1,7 +1,6 @@
-/* eslint-disable @typescript-eslint/ban-types */
 import { AsyncDisposableStack, DisposableSymbols } from '@whatwg-node/disposablestack';
 import * as DefaultFetchAPI from '@whatwg-node/fetch';
-import { completeAssign, ensureDisposableStackRegisteredForTerminateEvents, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, nodeRequestResponseMap, normalizeNodeRequest, sendNodeResponse, ServerAdapterRequestAbortSignal, } from './utils.js';
+import { completeAssign, ensureDisposableStackRegisteredForTerminateEvents, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, nodeRequestResponseMap, normalizeNodeRequest, sendNodeResponse, } from './utils.js';
 import { fakePromise, getRequestFromUWSRequest, isUWSResponse, sendResponseToUwsOpts, } from './uwebsockets.js';
 // Required for envs like nextjs edge runtime
 function isRequestAccessible(serverContext) {
@@ -24,54 +23,56 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     const onRequestHooks = [];
     const onResponseHooks = [];
     const waitUntilPromises = new Set();
-    const disposableStack = new AsyncDisposableStack();
-    const signals = new Set();
-    function registerSignal(signal) {
-        signals.add(signal);
-        signal.addEventListener('abort', () => {
-            signals.delete(signal);
-        });
-    }
-    disposableStack.defer(() => {
-        for (const signal of signals) {
-            signal.sendAbort();
-        }
-    });
-    disposableStack.defer(() => {
-        if (waitUntilPromises.size > 0) {
-            return Promise.allSettled(waitUntilPromises).then(() => {
-                waitUntilPromises.clear();
-            }, () => {
-                waitUntilPromises.clear();
+    let _disposableStack;
+    function ensureDisposableStack() {
+        if (!_disposableStack) {
+            _disposableStack = new AsyncDisposableStack();
+            if (options?.disposeOnProcessTerminate) {
+                ensureDisposableStackRegisteredForTerminateEvents(_disposableStack);
+            }
+            _disposableStack.defer(() => {
+                if (waitUntilPromises.size > 0) {
+                    return Promise.allSettled(waitUntilPromises).then(() => {
+                        waitUntilPromises.clear();
+                    }, () => {
+                        waitUntilPromises.clear();
+                    });
+                }
             });
         }
-    });
+        return _disposableStack;
+    }
     function waitUntil(promiseLike) {
-        // If it is a Node.js environment, we should register the disposable stack to handle process termination events
-        if (globalThis.process) {
-            ensureDisposableStackRegisteredForTerminateEvents(disposableStack);
+        // Ensure that the disposable stack is created
+        if (isPromise(promiseLike)) {
+            ensureDisposableStack();
+            waitUntilPromises.add(promiseLike);
+            promiseLike.then(() => {
+                waitUntilPromises.delete(promiseLike);
+            }, err => {
+                console.error(`Unexpected error while waiting: ${err.message || err}`);
+                waitUntilPromises.delete(promiseLike);
+            });
         }
-        waitUntilPromises.add(promiseLike);
-        promiseLike.then(() => {
-            waitUntilPromises.delete(promiseLike);
-        }, err => {
-            console.error(`Unexpected error while waiting: ${err.message || err}`);
-            waitUntilPromises.delete(promiseLike);
-        });
     }
     if (options?.plugins != null) {
         for (const plugin of options.plugins) {
-            if (plugin != null) {
-                if (plugin.onRequest) {
-                    onRequestHooks.push(plugin.onRequest);
-                }
-                if (plugin.onResponse) {
-                    onResponseHooks.push(plugin.onResponse);
-                }
-                const disposeFn = plugin[DisposableSymbols.asyncDispose] || plugin[DisposableSymbols.dispose];
-                if (disposeFn != null) {
-                    disposableStack.defer(disposeFn);
-                }
+            if (plugin.onRequest) {
+                onRequestHooks.push(plugin.onRequest);
+            }
+            if (plugin.onResponse) {
+                onResponseHooks.push(plugin.onResponse);
+            }
+            const disposeFn = plugin[DisposableSymbols.dispose];
+            if (disposeFn) {
+                ensureDisposableStack().defer(disposeFn);
+            }
+            const asyncDisposeFn = plugin[DisposableSymbols.asyncDispose];
+            if (asyncDisposeFn) {
+                ensureDisposableStack().defer(asyncDisposeFn);
+            }
+            if (plugin.onDispose) {
+                ensureDisposableStack().defer(plugin.onDispose);
             }
         }
     }
@@ -146,7 +147,11 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     // TODO: Remove this on the next major version
     function handleNodeRequest(nodeRequest, ...ctx) {
         const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};
-        const request = normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal);
+        // Ensure `waitUntil` is available in the server context
+        if (!serverContext.waitUntil) {
+            serverContext.waitUntil = waitUntil;
+        }
+        const request = normalizeNodeRequest(nodeRequest, fetchAPI);
         return handleRequest(request, serverContext);
     }
     function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
@@ -192,8 +197,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         const serverContext = filteredCtxParts.length > 0
             ? completeAssign(defaultServerContext, ...ctx)
             : defaultServerContext;
-        const signal = new ServerAdapterRequestAbortSignal();
-        registerSignal(signal);
+        const controller = new AbortController();
         const originalResEnd = res.end.bind(res);
         let resEnded = false;
         res.end = function (data) {
@@ -202,16 +206,16 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         };
         const originalOnAborted = res.onAborted.bind(res);
         originalOnAborted(function () {
-            signal.sendAbort();
+            controller.abort();
         });
         res.onAborted = function (cb) {
-            signal.addEventListener('abort', cb);
+            controller.signal.addEventListener('abort', cb, { once: true });
         };
         const request = getRequestFromUWSRequest({
             req,
             res,
             fetchAPI,
-            signal,
+            controller,
         });
         let response$;
         try {
@@ -224,8 +228,8 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             return response$
                 .catch((e) => handleErrorFromRequestHandler(e, fetchAPI.Response))
                 .then(response => {
-                if (!signal.aborted && !resEnded) {
-                    return sendResponseToUwsOpts(res, response, signal, fetchAPI);
+                if (!controller.signal.aborted && !resEnded) {
+                    return sendResponseToUwsOpts(res, response, controller, fetchAPI);
                 }
             })
                 .catch(err => {
@@ -233,8 +237,8 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             });
         }
         try {
-            if (!signal.aborted && !resEnded) {
-                return sendResponseToUwsOpts(res, response$, signal, fetchAPI);
+            if (!controller.signal.aborted && !resEnded) {
+                return sendResponseToUwsOpts(res, response$, controller, fetchAPI);
             }
         }
         catch (err) {
@@ -267,13 +271,17 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             if (isRequestInit(initOrCtx)) {
                 const request = new fetchAPI.Request(input, initOrCtx);
                 const res$ = handleRequestWithWaitUntil(request, ...restOfCtx);
-                return handleAbortSignalAndPromiseResponse(res$, initOrCtx?.signal);
+                const signal = initOrCtx.signal;
+                if (signal) {
+                    return handleAbortSignalAndPromiseResponse(res$, signal);
+                }
+                return res$;
             }
             const request = new fetchAPI.Request(input);
             return handleRequestWithWaitUntil(request, ...maybeCtx);
         }
         const res$ = handleRequestWithWaitUntil(input, ...maybeCtx);
-        return handleAbortSignalAndPromiseResponse(res$, input._signal);
+        return handleAbortSignalAndPromiseResponse(res$, input.signal);
     };
     const genericRequestHandler = (input, ...maybeCtx) => {
         // If it is a Node request
@@ -312,16 +320,18 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         handleEvent,
         handleUWS,
         handle: genericRequestHandler,
-        disposableStack,
+        get disposableStack() {
+            return ensureDisposableStack();
+        },
         [DisposableSymbols.asyncDispose]() {
-            if (!disposableStack.disposed) {
-                return disposableStack.disposeAsync();
+            if (_disposableStack && !_disposableStack.disposed) {
+                return _disposableStack.disposeAsync();
             }
             return fakePromise(undefined);
         },
         dispose() {
-            if (!disposableStack.disposed) {
-                return disposableStack.disposeAsync();
+            if (_disposableStack && !_disposableStack.disposed) {
+                return _disposableStack.disposeAsync();
             }
             return fakePromise(undefined);
         },

package/esm/index.js

@@ -7,3 +7,4 @@ export * from './plugins/useErrorHandling.js';
 export * from './plugins/useContentEncoding.js';
 export * from './uwebsockets.js';
 export { Response } from '@whatwg-node/fetch';
+export { DisposableSymbols } from '@whatwg-node/disposablestack';

package/esm/plugins/useContentEncoding.js

@@ -1,4 +1,4 @@
-import { decompressedResponseMap, getSupportedEncodings, isAsyncIterable, isReadable, } from '../utils.js';
+import { decompressedResponseMap, getSupportedEncodings } from '../utils.js';
 export function useContentEncoding() {
     const encodingMap = new WeakMap();
     return {
@@ -43,50 +43,19 @@ export function useContentEncoding() {
                 encodingMap.set(request, acceptEncoding.split(','));
             }
         },
-        onResponse({ request, response, setResponse, fetchAPI, serverContext }) {
-            // Hack for avoiding to create whatwg-node to create a readable stream until it's needed
-            if (response['bodyInit'] || response.body) {
+        onResponse({ request, response, setResponse, fetchAPI }) {
+            if (response.body) {
                 const encodings = encodingMap.get(request);
                 if (encodings) {
                     const supportedEncoding = encodings.find(encoding => getSupportedEncodings(fetchAPI).includes(encoding));
                     if (supportedEncoding) {
                         const compressionStream = new fetchAPI.CompressionStream(supportedEncoding);
-                        // To calculate final content-length
-                        const contentLength = response.headers.get('content-length');
-                        if (contentLength) {
-                            const bufOfRes = response._buffer;
-                            if (bufOfRes) {
-                                const writer = compressionStream.writable.getWriter();
-                                const write$ = writer.write(bufOfRes);
-                                serverContext.waitUntil?.(write$);
-                                const close$ = writer.close();
-                                serverContext.waitUntil?.(close$);
-                                const uint8Arrays$ = isReadable(compressionStream.readable['readable'])
-                                    ? collectReadableValues(compressionStream.readable['readable'])
-                                    : isAsyncIterable(compressionStream.readable)
-                                        ? collectAsyncIterableValues(compressionStream.readable)
-                                        : collectReadableStreamValues(compressionStream.readable);
-                                return uint8Arrays$.then(uint8Arrays => {
-                                    const chunks = uint8Arrays.flatMap(uint8Array => [...uint8Array]);
-                                    const uint8Array = new Uint8Array(chunks);
-                                    const newHeaders = new fetchAPI.Headers(response.headers);
-                                    newHeaders.set('content-encoding', supportedEncoding);
-                                    newHeaders.set('content-length', uint8Array.byteLength.toString());
-                                    const compressedResponse = new fetchAPI.Response(uint8Array, {
-                                        ...response,
-                                        headers: newHeaders,
-                                    });
-                                    decompressedResponseMap.set(compressedResponse, response);
-                                    setResponse(compressedResponse);
-                                    const close$ = compressionStream.writable.close();
-                                    serverContext.waitUntil?.(close$);
-                                });
-                            }
-                        }
                         const newHeaders = new fetchAPI.Headers(response.headers);
                         newHeaders.set('content-encoding', supportedEncoding);
                         newHeaders.delete('content-length');
-                        const compressedBody = response.body.pipeThrough(compressionStream);
+                        const compressedBody = response.body.pipeThrough(compressionStream, {
+                            signal: request.signal,
+                        });
                         const compressedResponse = new fetchAPI.Response(compressedBody, {
                             status: response.status,
                             statusText: response.statusText,
@@ -100,33 +69,3 @@ export function useContentEncoding() {
         },
     };
 }
-function collectReadableValues(readable) {
-    const values = [];
-    readable.on('data', value => values.push(value));
-    return new Promise((resolve, reject) => {
-        readable.once('end', () => resolve(values));
-        readable.once('error', reject);
-    });
-}
-async function collectAsyncIterableValues(asyncIterable) {
-    const values = [];
-    for await (const value of asyncIterable) {
-        values.push(value);
-    }
-    return values;
-}
-async function collectReadableStreamValues(readableStream) {
-    const reader = readableStream.getReader();
-    const values = [];
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            reader.releaseLock();
-            break;
-        }
-        else if (value) {
-            values.push(value);
-        }
-    }
-    return values;
-}