@nbtca/prompt 1.4.2 → 1.5.1

package/dist/features/docs-client.js

@@ -0,0 +1,225 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createDocsClient } from '@nbtca/docs';
+const contextKey = Symbol.for('@nbtca/prompt/docs-fetch-context/v2');
+const globalWithContext = globalThis;
+function abortError(signal) {
+    return signal.reason instanceof Error ? signal.reason : new DOMException('Aborted', 'AbortError');
+}
+function raceWithSignal(request, signal) {
+    if (!signal)
+        return request;
+    if (signal.aborted)
+        return Promise.reject(abortError(signal));
+    return new Promise((resolve, reject) => {
+        const finish = (result) => {
+            signal.removeEventListener('abort', onAbort);
+            result();
+        };
+        const onAbort = () => {
+            finish(() => {
+                reject(abortError(signal));
+            });
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        void request.then((value) => {
+            finish(() => {
+                resolve(value);
+            });
+        }, (error) => {
+            finish(() => {
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    });
+}
+function createDocsFetchContext() {
+    const installed = globalWithContext[contextKey];
+    if (installed)
+        return installed;
+    const nativeFetch = globalThis.fetch;
+    const storage = new AsyncLocalStorage();
+    let delegate = nativeFetch;
+    let fallbackDispatching = false;
+    const contextualFetch = (input, init) => {
+        const forward = (delegate, options) => options ? delegate(input, options) : delegate(input);
+        const store = storage.getStore();
+        if (!store) {
+            if (fallbackDispatching)
+                return forward(nativeFetch, init);
+            fallbackDispatching = true;
+            try {
+                return forward(delegate, init);
+            }
+            finally {
+                fallbackDispatching = false;
+            }
+        }
+        if (store.dispatching)
+            return forward(nativeFetch, init);
+        if (store.signal?.aborted)
+            return Promise.reject(abortError(store.signal));
+        const requestSignal = init?.signal;
+        const signal = store.signal
+            ? requestSignal
+                ? AbortSignal.any([store.signal, requestSignal])
+                : store.signal
+            : requestSignal;
+        store.dispatching = true;
+        try {
+            return raceWithSignal(forward(store.delegate, signal ? { ...init, signal } : init), signal);
+        }
+        finally {
+            store.dispatching = false;
+        }
+    };
+    const getFetch = () => (storage.getStore() ? contextualFetch : delegate);
+    const setFetch = (value) => {
+        delegate = value;
+    };
+    const context = {
+        active: 0,
+        contextualFetch,
+        get delegate() {
+            return delegate;
+        },
+        set delegate(value) {
+            delegate = value;
+        },
+        getFetch,
+        nativeFetch,
+        restoreDescriptor: undefined,
+        setFetch,
+        storage,
+    };
+    globalWithContext[contextKey] = context;
+    return context;
+}
+function beginDocsFetch() {
+    const context = createDocsFetchContext();
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'fetch');
+    const installedAccessor = descriptor?.get === context.getFetch && descriptor.set === context.setFetch;
+    const installedValue = descriptor?.value === context.contextualFetch;
+    if (context.active === 0)
+        context.restoreDescriptor = descriptor;
+    if (!installedAccessor && !installedValue) {
+        const observed = globalThis.fetch;
+        if (observed !== context.contextualFetch)
+            context.delegate = observed;
+        if (descriptor?.configurable === false) {
+            if (descriptor.writable !== true) {
+                return {
+                    context,
+                    finish() {
+                        return undefined;
+                    },
+                };
+            }
+            globalThis.fetch = context.contextualFetch;
+        }
+        else {
+            Object.defineProperty(globalThis, 'fetch', {
+                configurable: true,
+                enumerable: descriptor?.enumerable ?? true,
+                get: context.getFetch,
+                set: context.setFetch,
+            });
+        }
+    }
+    context.active += 1;
+    let finished = false;
+    return {
+        context,
+        finish() {
+            if (finished)
+                return;
+            finished = true;
+            context.active = Math.max(0, context.active - 1);
+            if (context.active > 0)
+                return;
+            const current = Object.getOwnPropertyDescriptor(globalThis, 'fetch');
+            if (current?.value === context.contextualFetch && current.writable === true) {
+                globalThis.fetch = context.delegate;
+                return;
+            }
+            if (current?.get !== context.getFetch || current.set !== context.setFetch)
+                return;
+            const restore = context.restoreDescriptor;
+            if (restore && ('get' in restore || 'set' in restore)) {
+                Object.defineProperty(globalThis, 'fetch', restore);
+            }
+            else {
+                Object.defineProperty(globalThis, 'fetch', {
+                    configurable: restore?.configurable ?? true,
+                    enumerable: restore?.enumerable ?? true,
+                    value: context.delegate,
+                    writable: restore?.writable ?? true,
+                });
+            }
+        },
+    };
+}
+const defaultClient = createDocsClient();
+const clientsBySignal = new WeakMap();
+const clients = new Set([defaultClient]);
+function clientFor(signal) {
+    if (!signal)
+        return defaultClient;
+    const existing = clientsBySignal.get(signal);
+    if (existing)
+        return existing;
+    const client = createDocsClient();
+    clientsBySignal.set(signal, client);
+    clients.add(client);
+    signal.addEventListener('abort', () => {
+        client.clear();
+        clients.delete(client);
+        clientsBySignal.delete(signal);
+    }, { once: true });
+    return client;
+}
+export function clearDocsClients() {
+    for (const client of clients)
+        client.clear();
+}
+export function runDocsClientOperation(signal, operation) {
+    if (signal?.aborted)
+        return Promise.reject(abortError(signal));
+    const scope = beginDocsFetch();
+    let request;
+    try {
+        request = scope.context.storage.run({ delegate: scope.context.delegate, dispatching: false, signal }, () => operation(clientFor(signal)));
+    }
+    catch (error) {
+        scope.finish();
+        return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener('abort', onAbort);
+            result();
+        };
+        const onAbort = () => {
+            settle(() => {
+                reject(signal ? abortError(signal) : new DOMException('Aborted', 'AbortError'));
+            });
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
+        void request.then((value) => {
+            scope.finish();
+            settle(() => {
+                resolve(value);
+            });
+        }, (error) => {
+            scope.finish();
+            settle(() => {
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    });
+}